test_Timer.cpp

Go to the documentation of this file.

#include "gtest/gtest.h"
 
#include "Kokkos_Macros.hpp"
#ifdef KOKKOS_ENABLE_EXPERIMENTAL_CXX20_MODULES
import kokkos.core;
#else
#include "Kokkos_Core.hpp"
#endif
 
#include "kokkos-utils/tests/scoped/ExecutionSpace.hpp"
#include "kokkos-utils/timer/Timer.hpp"

 
using execution_space = Kokkos::DefaultExecutionSpace;
 
namespace Kokkos::utils::tests::timer
{
 
using namespace Kokkos::utils::timer;
 
template <typename T>
struct TimerTest : public ::testing::Test,
                   public scoped::ExecutionSpace<execution_space>
{};
 
using TimerTypes = ::testing::Types<
    Timer<void>,
    Timer<execution_space>
>;
 
TYPED_TEST_SUITE(TimerTest, TimerTypes);

TYPED_TEST(TimerTest, invalid_if_not_started_and_not_stopped)
{
    const TypeParam timer;
    ASSERT_FALSE(timer.is_valid());
}

TYPED_TEST(TimerTest, invalid_if_not_stopped)
{
    TypeParam timer;
 
    if constexpr (std::same_as<TypeParam, void>) {
        timer.start();
    } else {
        timer.start(this->exec);
    }
 
    ASSERT_FALSE(timer.is_valid());
}

TYPED_TEST(TimerTest, invalid_if_not_started)
{
    TypeParam timer;
 
    if constexpr (std::same_as<TypeParam, void>) {
        timer.stop();
    } else {
        timer.stop(this->exec);
    }
 
    ASSERT_FALSE(timer.is_valid());
}

TYPED_TEST(TimerTest, valid_if_started_and_stopped)
{
    TypeParam timer;
 
    if constexpr (std::same_as<TypeParam, void>)
    {
        timer.start();
        timer.stop();
    }
    else
    {
        timer.start(this->exec);
        timer.stop(this->exec);
    }
 
    ASSERT_TRUE(timer.is_valid());
}
 
struct TimerExecutionSpaceTest : public TimerTest<execution_space> {
    using timer_t = Timer<execution_space>;
};

TEST_F(TimerExecutionSpaceTest, start_stop_elapsed)
{
    using view_t = Kokkos::View<double*, execution_space>;
 
    Kokkos::Timer timer_external;
    timer_t timer;
 
    timer_external.reset();
    timer.start(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.);
}

TYPED_TEST(TimerTest, duration)
{
    TypeParam timer;
 
    if constexpr (std::same_as<TypeParam, void>) {
        timer.start();
    } else {
        timer.start(this->exec);
    }
 
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
    if constexpr (std::same_as<TypeParam, void>) {
        timer.stop();
    } else {
        timer.stop(this->exec);
    }
 
    const double elapsed = timer.template duration<milliseconds>().count();

    ASSERT_GE(elapsed, 100.);

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

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

    const auto duration_se = timer.template 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.template duration<milliseconds>()));
}

TEST_F(TimerExecutionSpaceTest, 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.start(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