Benchmarking avec googletest?

Contexte (passez à la question ci-dessous si cela ne vous intéresse pas)

J’ai un simulateur qui traverse trois états:

  1. Démarrage à un seul thread (I / O ok)
  2. Etape de simulation liée à la CPU multi-thread en mémoire (I / O pas ok)
  3. Post-single threaded post-simulation, post-jointure (I / O ok)

Que diable! Lors des tests standard, l’utilisation du processeur a chuté de 100% à 20% , et la durée totale d’utilisation a été environ 30 fois plus longue que la normale (130 secondes contre 4,2 secondes).

Lorsque Callgrind ne révéla plus rien de suspect, ma tête bourdonna alors que j’étais sur le sharepoint revenir au dernier commit, perdant ainsi toutes les corrections de bugs.

Découragé, je suis entré dans la salle des serveurs pendant une course et j’ai remarqué des sons de grincement désagréables, qui auraient été causés ultérieurement par des écritures sur des sockets Mysql dans / proc / PID / fd !!! Il s’est avéré que le code Mysql, plusieurs couches profondes dans l’étape 2., posait problème.

Leçons apsockets

  1. Les E / S accidentelles peuvent être mortelles pour une application en temps réel
  2. Les tests unitaires ne suffisent pas: j’ai aussi besoin d’parsings comparatives

Correctif J’introduirai IOSentinels et asserts () de stockage local de thread sur ReadAllowed () et WriteAllowed () afin de garantir que les threads de l’étape 2 ne feront jamais d’IO.

Question

Quelqu’un at-il un peu de chance avec l’attachement / l’écriture d’un framework de benchmarking avec googletest?

Malheureusement, tous mes googlets ont passé cette fois. Si je m’étais éloigné un peu et que je revenais sans remarquer le temps d’exécution, cela aurait été un commit désastreux, et peut-être beaucoup plus difficile à réparer.

Je voudrais que googletest échoue si une exécution prend> 2 ou 3 fois la dernière exécution: cette dernière partie est délicate car, dans le cas d’une exécution très rapide, l’état du système peut provoquer une perte de temps deux fois plus longue, mais tout de même. Mais pour une longue simulation / simulation, je ne m’attends pas à ce que les durées d’exécution changent considérablement (> 50% serait inhabituel).

Je suis ouvert aux suggestions ici, mais il serait bien d’avoir une vérification nécessitant peu d’entretien qui fonctionnerait avec des tests automatisés, de sorte que le fait que le système devienne soudainement lent, même si toutes les sorties semblent correctes, sera évident.

N’est-ce pas aussi simple que cela?

 const clock_t t0 = clock(); // or gettimeofday or whatever int res = yourFunction(); const clock_t t1 = clock(); const double elapsedSec = (t1 - t0) / (double)CLOCKS_PER_SEC; EXPECT_EQ(EXPECTED, res); EXPECT_GT(10.0, elapsedSec); 

Ici, vous devez modifier manuellement 10.0 fonction de votre tâche.

Bien sûr, vous pouvez aller plus loin avec quelque chose comme:

 double prev = -1; { ifstream ifs("/var/tmp/time_record.txt"); ifs >> prev; } if (prev < 0) prev = DEFAULT_VALUE; // ... EXPECT_GT(2 * prev, elapsedSec); { ofstream ofs("/var/tmp/time_record.txt"); ofs << elapsedSec << endl; } 

Mais je me demande si cette complexité supplémentaire peut vraiment être justifiée.

Google Test Framework propose par défaut une mesure du temps écoulé. Il est commandé par une variable d’environnement, GTEST_PRINT_TIME . La variable par défaut est 1 .

Alors, pourquoi ne pas surveiller le temps écoulé à l’aide de cette fonctionnalité de la plateforme Google Test?

Voici un mot sur la variable de temps écoulé dans Google Test .

Quelques mises à jour sur cette question (en 2016):

  1. Voici un joli post sur le blog de Nick Brunn à propos de son cadre d’parsing comparative Hayai . (2012)

    • Il ne fournit pas la possibilité de spécifier des exigences de temps d’exécution.
    • Il est très similaire à Google Test. Syntaxe, etc.
    • Il fournit les résultats de l’parsing comparative à l’utilisateur ou à une infrastructure d’continuous integration. Consultez également la fourchette de MojaveWastelander pour son développement actif et le support MSVC.
  2. Google a publié “Benchmark” en 2014 . Cela fournit un comportement similaire à celui de Hayai ci-dessus. Autant que je sache, définir les exigences n’est pas possible. Encore une fois, la syntaxe est inspirée de GoogleTest.

    • Il existe même des fonctionnalités avancées telles que la mesure de la complexité (big-O).
  3. GoogleTest a cela comme une fonctionnalité ouverte sur Github . L’ implémentation est rudimentaire, mais ne fait pas encore partie de GoogleTest.