src/gallium/state_trackers/clover/core/event.hpp

   1 //
   2 // Copyright 2012 Francisco Jerez
   3 //
   4 // Permission is hereby granted, free of charge, to any person obtaining a
   5 // copy of this software and associated documentation files (the "Software"),
   6 // to deal in the Software without restriction, including without limitation
   7 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 // and/or sell copies of the Software, and to permit persons to whom the
   9 // Software is furnished to do so, subject to the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be included in
  12 // all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 // OTHER DEALINGS IN THE SOFTWARE.
  21 //
  22
  23 #ifndef CLOVER_CORE_EVENT_HPP
  24 #define CLOVER_CORE_EVENT_HPP
  25
  26 #include <condition_variable>
  27 #include <functional>
  28
  29 #include "core/object.hpp"
  30 #include "core/queue.hpp"
  31 #include "core/timestamp.hpp"
  32 #include "util/lazy.hpp"
  33
  34 namespace clover {
  35    ///
  36    /// Class that represents a task that might be executed
  37    /// asynchronously at some point in the future.
  38    ///
  39    /// An event consists of a list of dependencies, a boolean
  40    /// signalled() flag, and an associated task.  An event is
  41    /// considered signalled as soon as all its dependencies (if any)
  42    /// are signalled as well, and the trigger() method is called; at
  43    /// that point the associated task will be started through the
  44    /// specified \a action_ok.  If the abort() method is called
  45    /// instead, the specified \a action_fail is executed and the
  46    /// associated task will never be started.  Dependent events will
  47    /// be aborted recursively.
  48    ///
  49    /// The execution status of the associated task can be queried
  50    /// using the status() method, and it can be waited for completion
  51    /// using the wait() method.
  52    ///
  53    class event : public ref_counter, public _cl_event {
  54    public:
  55       typedef std::function<void (event &)> action;
  56
  57       event(clover::context &ctx, const ref_vector<event> &deps,
  58             action action_ok, action action_fail);
  59       virtual ~event();
  60
  61       event(const event &ev) = delete;
  62       event &
  63       operator=(const event &ev) = delete;
  64
  65       void trigger();
  66       void abort(cl_int status);
  67       bool signalled() const;
  68
  69       virtual cl_int status() const = 0;
  70       virtual command_queue *queue() const = 0;
  71       virtual cl_command_type command() const = 0;
  72       virtual void wait() const;
  73
  74       virtual struct pipe_fence_handle *fence() const {
  75          return NULL;
  76       }
  77
  78       const intrusive_ref<clover::context> context;
  79
  80    protected:
  81       void chain(event &ev);
  82
  83       cl_int _status;
  84       std::vector<intrusive_ref<event>> deps;
  85
  86    private:
  87       std::vector<intrusive_ref<event>> trigger_self();
  88       std::vector<intrusive_ref<event>> abort_self(cl_int status);
  89
  90       unsigned wait_count;
  91       action action_ok;
  92       action action_fail;
  93       std::vector<intrusive_ref<event>> _chain;
  94       mutable std::condition_variable cv;
  95       mutable std::mutex mutex;
  96    };
  97
  98    ///
  99    /// Class that represents a task executed by a command queue.
 100    ///
 101    /// Similar to a normal clover::event.  In addition it's associated
 102    /// with a given command queue \a q and a given OpenCL \a command.
 103    /// hard_event instances created for the same queue are implicitly
 104    /// ordered with respect to each other, and they are implicitly
 105    /// triggered on construction.
 106    ///
 107    /// A hard_event is considered complete when the associated
 108    /// hardware task finishes execution.
 109    ///
 110    class hard_event : public event {
 111    public:
 112       hard_event(command_queue &q, cl_command_type command,
 113                  const ref_vector<event> &deps,
 114                  action action = [](event &){});
 115       ~hard_event();
 116
 117       virtual cl_int status() const;
 118       virtual command_queue *queue() const;
 119       virtual cl_command_type command() const;
 120       virtual void wait() const;
 121
 122       const lazy<cl_ulong> &time_queued() const;
 123       const lazy<cl_ulong> &time_submit() const;
 124       const lazy<cl_ulong> &time_start() const;
 125       const lazy<cl_ulong> &time_end() const;
 126
 127       friend class command_queue;
 128
 129       virtual struct pipe_fence_handle *fence() const {
 130          return _fence;
 131       }
 132
 133    private:
 134       virtual void fence(pipe_fence_handle *fence);
 135       action profile(command_queue &q, const action &action) const;
 136
 137       const intrusive_ref<command_queue> _queue;
 138       cl_command_type _command;
 139       pipe_fence_handle *_fence;
 140       lazy<cl_ulong> _time_queued, _time_submit, _time_start, _time_end;
 141    };
 142
 143    ///
 144    /// Class that represents a software event.
 145    ///
 146    /// A soft_event is not associated with any specific hardware task
 147    /// or command queue.  It's considered complete as soon as all its
 148    /// dependencies finish execution.
 149    ///
 150    class soft_event : public event {
 151    public:
 152       soft_event(clover::context &ctx, const ref_vector<event> &deps,
 153                  bool trigger, action action = [](event &){});
 154
 155       virtual cl_int status() const;
 156       virtual command_queue *queue() const;
 157       virtual cl_command_type command() const;
 158       virtual void wait() const;
 159    };
 160 }
 161
 162 #endif