event.hpp

Go to the documentation of this file.

#pragma once
#ifndef CUDA_API_WRAPPERS_EVENT_HPP_
#define CUDA_API_WRAPPERS_EVENT_HPP_

#include <cuda/api/constants.hpp>
#include <cuda/api/current_device.hpp>
#include <cuda/api/error.hpp>
#include <cuda/api/ipc.hpp>
#include <cuda/common/types.hpp>

#include <cuda_runtime_api.h>

#include <chrono> // for duration types

namespace cuda {

class device_t;
class stream_t;

namespace event {

namespace detail_ {

inline void enqueue(stream::id_t stream_id, id_t event_id) {
    auto status = cudaEventRecord(event_id, stream_id);
    cuda::throw_if_error(status,
        "Failed recording event " + cuda::detail_::ptr_as_hex(event_id)
        + " on stream " + cuda::detail_::ptr_as_hex(stream_id));
}

constexpr unsigned inline make_flags(bool uses_blocking_sync, bool records_timing, bool interprocess)
{
    return
          ( uses_blocking_sync  ? cudaEventBlockingSync : 0  )
        | ( records_timing      ? 0 : cudaEventDisableTiming )
        | ( interprocess        ? cudaEventInterprocess : 0  );
}

} // namespace detail_

} // namespace event

class event_t;

namespace event {

namespace detail_ {
event_t wrap(
    device::id_t  device_id,
    id_t          event_id,
    bool          take_ownership = false) noexcept;

} // namespace detail_

} // namespace event

inline void synchronize(const event_t& event);

class event_t {
public: // data member non-mutator getters
    event::id_t  id()                 const noexcept{ return id_;                 }
    device::id_t device_id()          const noexcept { return device_id_;          }
    device_t     device() const noexcept;
    bool         is_owning()          const noexcept { return owning;              }

public: // other non-mutator methods

    bool has_occurred() const
    {
        auto status = cudaEventQuery(id_);
        if (status == cuda::status::success) return true;
        if (status == cuda::status::not_ready) return false;
        throw cuda::runtime_error(status,
            "Could not determine whether event " + detail_::ptr_as_hex(id_)
            + "has already occurred or not.");
    }

    bool query() const { return has_occurred(); }


public: // other mutator methods


    void record()
    {
        event::detail_::enqueue(stream::default_stream_id, id_);
    }

    void record(const stream_t& stream);

    void fire(const stream_t& stream);

    void synchronize()
    {
        return cuda::synchronize(*this);
    }

protected: // constructors

    event_t(device::id_t device_id, event::id_t event_id, bool take_ownership) noexcept
    : device_id_(device_id), id_(event_id), owning(take_ownership) { }

public: // friendship

    friend event_t event::detail_::wrap(device::id_t device_id, event::id_t event_id, bool take_ownership) noexcept;

public: // constructors and destructor

    event_t(const event_t& other) noexcept : event_t(other.device_id_, other.id_, false) { }

    event_t(event_t&& other) noexcept :
        event_t(other.device_id_, other.id_, other.owning)
    {
        other.owning = false;
    };

    ~event_t()
    {
        if (owning) { cudaEventDestroy(id_); }
    }

public: // operators

    event_t& operator=(const event_t& other) = delete;
    event_t& operator=(event_t&& other) = delete;

protected: // data members
    const device::id_t  device_id_;
    const event::id_t   id_;
    bool                owning;
        // this field is mutable only for enabling move construction; other
        // than in that case it must not be altered
};

namespace event {

using duration_t = ::std::chrono::duration<float, ::std::milli>;

inline duration_t time_elapsed_between(const event_t& start, const event_t& end)
{
    float elapsed_milliseconds;
    auto status = cudaEventElapsedTime(&elapsed_milliseconds, start.id(), end.id());
    cuda::throw_if_error(status, "determining the time elapsed between events");
    return duration_t { elapsed_milliseconds };
}

namespace detail_ {

inline event_t wrap(
    device::id_t  device_id,
    id_t          event_id,
    bool          take_ownership) noexcept
{
    return event_t(device_id, event_id, take_ownership);
}

// Note: For now, event_t's need their device's ID - even if it's the current device;
// that explains the requirement in this function's interface
inline event_t create_on_current_device(
    device::id_t  current_device_id,
    bool          uses_blocking_sync,
    bool          records_timing,
    bool          interprocess)
{
    auto flags = make_flags(uses_blocking_sync, records_timing, interprocess);
    cuda::event::id_t new_event_id;
    auto status = cudaEventCreateWithFlags(&new_event_id, flags);
    cuda::throw_if_error(status, "failed creating a CUDA event associated with the current device");
    // Note: We're trusting CUDA to actually have succeeded if it reports success,
    // so we're not checking the newly-created event id - which is really just
    // a pointer - for nullness
    return wrap(current_device_id, new_event_id, do_take_ownership);
}

inline event_t create(
    device::id_t  device_id,
    bool          uses_blocking_sync,
    bool          records_timing,
    bool          interprocess)
{
    device::current::detail_::scoped_override_t
        set_device_for_this_scope(device_id);
    return detail_::create_on_current_device(device_id, uses_blocking_sync, records_timing, interprocess);
}

} // namespace detail_

inline event_t create(
    device_t&  device,
    bool       uses_blocking_sync = sync_by_busy_waiting, // Yes, that's the runtime default
    bool       records_timing     = do_record_timings,
    bool       interprocess       = not_interprocess);

} // namespace event

inline void synchronize(const event_t& event)
{
    auto device_id = event.device_id();
    auto event_id = event.id();
    device::current::detail_::scoped_override_t device_for_this_scope(device_id);
    auto status = cudaEventSynchronize(event_id);
    throw_if_error(status, "Failed synchronizing the event with id "
        + cuda::detail_::ptr_as_hex(event_id) + " on   " + ::std::to_string(device_id));
}

} // namespace cuda

#endif // CUDA_API_WRAPPERS_EVENT_HPP_