Comment obtenir les tiques de QueryPerformanceCounter en C#?

J'ai besoin de remplacer Chronomètre pour éviter d'utiliser des accesseurs pour ses propriétés. Je vais la mettre en œuvre à l'aide de QueryPerformanceCounter. J'ai seulement besoin de tiques rien d'autre.

Quelqu'un peut-il fournir un code snipet s'il vous plaît, pour obtenir de bons tiques (1/10000 de ms) ou tout autre petit mais stable de la valeur.

Veuillez noter mon serveur définit la granularité de l'horloge en bas à 0,5 ms (pas sûr si elle affecte QueryPerformanceCounter) mais juste pour que vous le sachiez.

Veuillez également noter - je n'ai pas besoin d'une minuterie. J'ai seulement besoin de mesurer des intervalles de temps entre les parties de code.

EDIT: pour éviter toute confusion, je veux vraiment savoir ce qui est lpPerformanceCount dans QueryPerformanceCounter(longue lpPerformanceCount);

Si vous êtes à la mesure des intervalles de temps entre les parties de code, comment est-ce différent d'un autre timer? De toute façon, vous pouvez utiliser l'interopérabilité à l'appel de la Kernel32.dll's QueryPerformanceCounter vous-même.
Pourriez-vous expliquer pourquoi vous voulez le faire "pour éviter d'utiliser les accesseurs pour ses propriétés" ne fait pas beaucoup de raison. Le problème avec QueryPerformanceCounter est qu'il retourne la valeur du nombre et de la quantité de comptes par seconde est variable en fonction de l'architecture et de peut être trouvé à l'aide de QueryPerformanceFrequency. Avec un chronomètre, vous obtenez la valeur qui est une unité de temps.
il fait beaucoup de sens pour moi sinon j'ai l'habitude de poser.
J'ai été un membre actif de débordement de pile pour un bon bout de temps et je dois dire que juste parce que quelqu'un pose une question n'est pas qu'il a un sens, est en fait la bonne question, ou en fonction en matière de validité des hypothèses. Nous ne sommes pas vos sujets ici pour faire votre volonté, un peu d'explication de votre raisonnement peut aller un long chemin vers la résolution de votre problème (que vous n'avez pas expliqué) plutôt que de simplement répondre à ce qui peut ou peut ne pas être la mauvaise question.
c'est ouvert à la communauté. j'ai une question et c'est rien à faire avec vous d'être ici depuis un moment et pensez-vous qu'il est tort ou raison. vous n'avez pas de réponse? veuillez déplacer le long.

OriginalL'auteur Boppity Bop | 2012-03-20

.net-4.0 c#

5
```
[DllImport("Kernel32.dll")]
private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);

[DllImport("Kernel32.dll")]
private static extern bool QueryPerformanceFrequency(out long lpFrequency);
```
Prises de http://www.codeproject.com/Articles/2635/High-Performance-Timer-in-C

Vieux, mais il doit encore travailler

EDIT: Le fonctionnement interne de StopWatch réellement utiliser QueryPerformanceCounter, donc, en utilisant le code managé devrait fournir des résultats identiques, avec une meilleure compatibilité.

Oui, je sais. de tous ce que j'ai trouvé sur le web, dont la codeproject vous vous référez - il montre secondes et nécessite une division par 'fréquence'... Mon point de cette question est de savoir quelle est la valeur qu'elle renvoie et comment puis-je l'utiliser sans fréquence. Je suis prêt à le rendre dépendant à un particulier, le programme d'installation sans portabilité (en fout). Juste besoin de comprendre ce qui lpPerformanceCount est en réalité.
lpPerformanceCount est le nombre de tiques (est différent pour chaque système), lpFrequency est le nombre de ticks par seconde. Pour obtenir le temps réel, vous diviserez lpPerformanceCount par lpFrequency pour obtenir le montant en quelques secondes. qpc(out time1); ...; qpc(out time2); long diff_in_ms = (time2-time1) * 1000 / frequency
Juste pour clarifier, je veux dire la fréquence est différente pour chaque système.
comme pour votre formule -- pourquoi avez-vous multiplier le résultat par 1000? Puisque la fréquence est tiques/seconde, vous avez juste besoin de multiplier les tiques en fonction de la fréquence pour obtenir l'intervalle de temps en secondes.
bon point, la variable est appelée diff_in_ms. Je suppose que ce que j'ai copié à partir de millisecondes nécessaires.

OriginalL'auteur Matthew
10

http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.gettimestamp.aspx

Stopwatch.GetTimestamp

Vous n'avez pas à instancier un Stopwatch objet, GetTimestamp doit retourner le nombre de tiques, indépendamment de son contexte.

OriginalL'auteur Matthew
1

Ne PAS utiliser le Chronomètre pour la haute résolution de chronométrage sans le tester. Il a été quelques années depuis que je l'ai testé, mais à l'époque, il a donné le windows par défaut de temps de résolution. Vous pouvez le dire, car vraiment, très vite les choses vont prendre 0 temps ou de 10 à 15 millisecondes si c'est à l'aide de windows par défaut de la résolution (la résolution par défaut est en fait de la résolution de fil des changements de contexte, sans doute par défaut de l'horloge windows est mis à jour à chaque changement de contexte, qui est d'environ tous les 10 à 15 millisecondes).

La meilleure façon de tester est d'utiliser Stopwatch.IsHighResolution

OriginalL'auteur John Robertson
0

PAS UNE RÉPONSE DIRECTE (mais Potentiellement soutien nécessaire info suivante):

Certaines réponses sont assez bon pour répondre directement à votre question. Cependant, pour accomplir ce que vous êtes en train de faire, je voudrais ajouter quelques remarques.

Tout d'abord, prendre en compte le calendrier des frais indirects de la juste-à-temps (jit) compilateur qui se passe au moment de l'exécution. Code où vous prenez la première timestamp puis faire trucs, et puis, prenez un dernier timestamp pour soustraire t2-t1 pour le delta, pour toute fonctionnalité à l'intérieur de trucs, si vous incluez toutes les fonctions que vous n'avez pas appelé encore pendant le processus actuel alors la première fois que vous l'appelez, vous devrez payer pour l'équipe de frais généraux pour la compilation du bytecode en code natif. Dans ce cas, le coût n'est pas représentatif de la réelle de l'exécution coût de l'exécution de code critique qui est vraisemblablement le code qui est appelé fréquemment et dont, jit coût est payé une seule fois (sur le premier appel à elle dans le processus). Alors, appelez la temporisation de code plusieurs fois, jeter le premier calendrier, et de prendre une moyenne.

En outre, méfiez-vous des coûts d'exécution du garbage collector. Si vous êtes en train de jouer, alors il peut être possible et intéressant de comparer le code que strictement évite de l'attribution de nouveaux objets. Mais parfois, ce n'est pas facile, surtout lorsque vous appelez des fonctions dont les implémentations vous ne pouvez pas modifier. Aussi, je dois vous accorder que le monde réel des performances de production de code ne peut pas éviter la collecte des ordures frais généraux afin d'obtenir un chiffre réaliste devrait inclure ces frais. Cela dit, si votre trucs contient le code qui alloue de nouveaux objets, il peut lancer le garbage collector qui sera cher, alors préparez-vous pour quelques valeurs aberrantes potentielles que vous pourriez vouloir jeter.

Deuxième, les bonnes réponses le code pour déclarer des fonctions externes à l'appel de dll système et c'est génial. L'obtention de ces signatures correctes dans le cas général, peut être une nuisance parfois donc, je voudrais mentionner une grande ressource pour le présent: pinvoke.net.
Une recherche de QueryPerformanceCounter m'a donné les signatures qui m'a mis un copier-coller à l'écart de la réponse déjà donnée et c'est une excellente ressource pour n'importe quel système d'appels que vous voulez faire.

http://pinvoke.net/search.aspx?search=QueryPerformanceCounter&namespace=%5BTous%5D

il est peut être utile pour les personnes qui ne le sont pas .net professionnels. le point de mesure de la performance est juste que la mesure de la performance. si votre code attend sur GC - il doit être reflétée dans les stats.. ce n'est pas un projet scientifique.. si, dans la pratique de votre application est de frapper GC, il ne faut pas, c'est le problème qui doit être une) découvert (à l'aide de la perfcounters, j'ai demandé) b) visées par les dev (autre histoire). merci pour l'idée sur l'utilisation des objets du noyau. mais je ne pense pas que c'est une bonne idée, commutation de mode noyau prend du temps et défie l'essence de ce que j'avais demandé

OriginalL'auteur Kthxbye

-1

I don't remember from where I copied it, but this code works well for me:

        public class QueryPerfCounter
    {
        [DllImport("KERNEL32")]
        private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);
        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceFrequency(out long lpFrequency);
    private long start;
    private long stop;
    private long frequency;
    double multiplier = 1.0e6;  //usecs /sec

    public QueryPerfCounter()
    {
        if (QueryPerformanceFrequency(out frequency) == false)
        {
            //Frequency not supported
            throw new Win32Exception();
        }
    }

    public void Start()
    {
        QueryPerformanceCounter(out start);
    }

    public void Stop()
    {
        QueryPerformanceCounter(out stop);
    }

    public double Duration(int iterations)
    {
        return ((((stop - start) * multiplier) / frequency) / iterations);
    }
}

OriginalL'auteur CElliott

Vous devez vous connecter pour publier un commentaire.