test_Timer.cpp

Go to the documentation of this file.

#include "gtest/gtest.h"
 
#include "Kokkos_Core.hpp"
 
#include "kokkos-utils/timer/Timer.hpp"

 
using execution_space = Kokkos::DefaultExecutionSpace;
 
namespace Kokkos::utils::tests::timer
{
 
using namespace Kokkos::utils::timer;
 
using timer_t = Timer<execution_space>;
 
class TimerTest : public ::testing::Test
{
public:
    void SetUp() override {
        this->exec = Kokkos::Experimental::partition_space(execution_space{}, 1)[0];
    }
 
protected:
    execution_space exec {};
};

TEST_F(TimerTest, invalid_if_not_reset_and_not_stopped)
{
    const timer_t timer;
    ASSERT_FALSE(timer.is_valid());
}

TEST_F(TimerTest, invalid_if_not_stopped)
{
    timer_t timer;
    timer.reset(this->exec);
    ASSERT_FALSE(timer.is_valid());
}

TEST_F(TimerTest, invalid_if_not_reset)
{
    timer_t timer;
    timer.stop(this->exec);
    ASSERT_FALSE(timer.is_valid());
}

TEST_F(TimerTest, valid_if_reset_and_stopped)
{
    timer_t timer;
    timer.reset(this->exec);
    timer.stop (this->exec);
    ASSERT_TRUE(timer.is_valid());
}

TEST_F(TimerTest, start_stop_elapsed)
{
    using view_t = Kokkos::View<double*, execution_space>;
 
    Kokkos::Timer timer_external;
    timer_t timer;
 
    timer_external.reset();
    timer.reset(this->exec);
 
    const view_t my_view(Kokkos::view_alloc(Kokkos::WithoutInitializing, this->exec, "my view"), 10);
    Kokkos::deep_copy(exec, my_view, 1.0);
 
    timer.stop(this->exec);
 
    const auto elapsed = timer.duration<seconds>().count();

    const auto elapsed_external = timer_external.seconds();
 
    ASSERT_LE(elapsed, elapsed_external);
    ASSERT_GE(elapsed, 0.);
    ASSERT_GE(elapsed_external, 0.);
}

TEST_F(TimerTest, duration)
{
    timer_t timer;
 
    timer.reset(this->exec);
 
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
    timer.stop(this->exec);
 
    const double elapsed = timer.duration<milliseconds>().count();

    ASSERT_GE(elapsed, 100.);

    const auto duration_ms = timer.duration<milliseconds>();
    ASSERT_NEAR(duration_ms.count(), elapsed, /* abs_error */ 1e-3);

    const auto duration_us = timer.duration<microseconds>();
    ASSERT_NEAR(duration_us.count(), elapsed * 1e3, /* abs_error */ 1.);

    const auto duration_se = timer.duration<seconds>();
    ASSERT_NEAR(duration_se.count(), elapsed / 1e3, /* abs_error */ 1e-6);

    ASSERT_LE(abs(duration_ms - duration_us), std::chrono::microseconds(1));
    ASSERT_LE(abs(duration_ms - duration_se), std::chrono::microseconds(1));

    ASSERT_EQ(duration_ms, (timer.duration<milliseconds>()));
}

 TEST_F(TimerTest, reuse)
{
    constexpr size_t nreps = 10;
 
    constexpr std::chrono::milliseconds wait(14);
 
    timer_t timer;
 
    for(size_t irep = 0; irep < nreps; ++irep)
    {
        const Kokkos::Timer timer_external;
 
        timer.reset(this->exec);
 
        this->exec.fence("ensure that the event 'started'");
 
        std::this_thread::sleep_for(wait);
 
        timer.stop(this->exec);
 
        const auto elapsed = timer.duration<milliseconds>();
 
        const seconds elapsed_external(timer_external.seconds());

        ASSERT_GE(elapsed, wait);
        ASSERT_LE(elapsed, elapsed_external);
    }
}
 
} // namespace Kokkos::utils::tests::timer