Temporizador de impulso: ¿cómo establecer el nivel de detalle, quiero microsegundos?

Así que trato de crear un banco de velocidad simple con boost 1.47.0. Pero resultados como 1.423 no son lo suficientemente detallados para mí. Necesito unos más detallados. ¿Cómo conseguirlo? ¿Cómo hacer que boost :: timer muestre microsegundos?

código de banco:

#include <iostream>
#include <boost/thread.hpp>
#include <map>
#include <boost/thread.hpp>
#include <boost/thread/locks.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int_distribution.hpp>
#include <boost/random.hpp>
#include <boost/timer.hpp>
#include <boost/progress.hpp>

class TestDs 
{
public:

    virtual bool containsKey(int key)=0;
    virtual int get(int key)=0;
    virtual int put(int key, int value)=0;
    virtual int remove(int key)=0;

    virtual int size()=0;
    virtual const char* name()=0;
    virtual void print()=0;
    virtual void shutdown()=0;
};

class GeneralMap: public TestDs
{
private:

    std::map<int,int> _ds;
    mutable boost::mutex mut_;
public:
    GeneralMap() {}

    bool containsKey(int key) {
        boost::mutex::scoped_lock lock(mut_);
        if ( _ds.find(key) != _ds.end())
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    int get(int key) {
        boost::mutex::scoped_lock lock(mut_);
        return _ds[key];
    }

    int put(int key, int value) {
        boost::mutex::scoped_lock lock(mut_);
        _ds.insert(std::pair<int, int>(key,value));
        return key;
    }

    int remove(int key) {
        boost::mutex::scoped_lock lock(mut_);
        return _ds.erase(key);
    }

    int size() {
        boost::mutex::scoped_lock lock(mut_);
        return _ds.size();
    }
    const char* name() {
        return "StdMap";
    }
    void print() {}
    void shutdown() {}

};


int n;
boost::shared_mutex  tests;
boost::shared_mutex  results;
boost::random::mt19937 rng;
boost::timer timerForCaptureFame;
GeneralMap Ds;
boost::progress_display *show_progress;

void test( int i)
{
    boost::shared_lock<boost::shared_mutex> lock_r(results);
    boost::shared_lock<boost::shared_mutex> lock(tests);
    Ds.put(i, 0);
    if (Ds.containsKey(i))
    {
        Ds.get(i);
    }
    Ds.remove(i);
    ++(*show_progress);

}

void result()
{
    boost::upgrade_lock<boost::shared_mutex> lock(results);
    boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);

    std::cout <<  std::endl << "test of " << Ds.name() << " complite;" << std::endl << "test performed on " << n << " items" << std::endl << "test duration: " << timerForCaptureFame.elapsed() << std::endl;
}

void create_tests( int n)
{

    boost::upgrade_lock<boost::shared_mutex> lock(tests);
    boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);

    boost::shared_lock<boost::shared_mutex> lock_r(results);

    for(int i=0; i<n; i++)
    {
        boost::random::uniform_int_distribution<> ran = boost::random::uniform_int_distribution<>(1, n*10);
        int x = ran(rng);
        boost::thread worker(test, x);
    }
    boost::thread worker_r(result);
    timerForCaptureFame.restart();
    return;
}



int main()
{
    n = 1000;
    show_progress = new boost::progress_display(n);
    create_tests(n);
    std::cin.get();
    return 0;
}

preguntado el 27 de agosto de 11 a las 20:08

2 Respuestas

¿Cómo hacer que boost :: timer muestre microsegundos?

La biblioteca del temporizador de Boost depende de la función clock () de la biblioteca estándar de C y CLOCKS_PER_SEC. Esa resolución máxima que puede obtener depende de eso, por lo que primero investigaría eso para ver si su sistema admite una resolución de microsegundos.

MSVC está configurado en CLOCKS_PER_SEC == 1000, por lo que no podría obtener una resolución de microsegundos si eso es lo que está compilando. Otros sistemas admiten CLOCKS_PER_SECOND == 1000000, por lo que debería considerar establecer un formato de salida fijo y establecer una precisión para dobles:

std::cout << std::fixed << std::precision(6) << timerForCaptureFame.elapsed();

Respondido 28 ago 11, 01:08

Mira si esto hilo de la página de correo de Boost ayuda.
Y podrías mirar esto stackoverflow pregunta

contestado el 23 de mayo de 17 a las 12:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.