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 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 18 // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 19 // OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 20 // SOFTWARE. 21 // 22 23 #ifndef __CORE_EVENT_HPP__ 24 #define __CORE_EVENT_HPP__ 25 26 #include <functional> 27 28 #include "core/base.hpp" 29 #include "core/queue.hpp" 30 31 namespace clover { 32 typedef struct _cl_event event; 33 } 34 35 /// 36 /// Class that represents a task that might be executed asynchronously 37 /// at some point in the future. 38 /// 39 /// An event consists of a list of dependencies, a boolean signalled() 40 /// flag, and an associated task. An event is considered signalled as 41 /// soon as all its dependencies (if any) are signalled as well, and 42 /// the trigger() method is called; at that point the associated task 43 /// will be started through the specified \a action_ok. If the 44 /// abort() method is called instead, the specified \a action_fail is 45 /// executed and the associated task will never be started. Dependent 46 /// events will be aborted recursively. 47 /// 48 /// The execution status of the associated task can be queried using 49 /// the status() method, and it can be waited for completion using the 50 /// wait() method. 51 /// 52 struct _cl_event : public clover::ref_counter { 53 public: 54 typedef std::function<void (clover::event &)> action; 55 56 _cl_event(clover::context &ctx, std::vector<clover::event *> deps, 57 action action_ok, action action_fail); 58 virtual ~_cl_event(); 59 60 void trigger(); 61 void abort(cl_int status); 62 bool signalled() const; 63 64 virtual cl_int status() const = 0; 65 virtual cl_command_queue queue() const = 0; 66 virtual cl_command_type command() const = 0; 67 virtual void wait() const = 0; 68 69 clover::context &ctx; 70 71 protected: 72 void chain(clover::event *ev); 73 74 cl_int __status; 75 std::vector<clover::ref_ptr<clover::event>> deps; 76 77 private: 78 unsigned wait_count; 79 action action_ok; 80 action action_fail; 81 std::vector<clover::ref_ptr<clover::event>> __chain; 82 }; 83 84 namespace clover { 85 /// 86 /// Class that represents a task executed by a command queue. 87 /// 88 /// Similar to a normal clover::event. In addition it's associated 89 /// with a given command queue \a q and a given OpenCL \a command. 90 /// hard_event instances created for the same queue are implicitly 91 /// ordered with respect to each other, and they are implicitly 92 /// triggered on construction. 93 /// 94 /// A hard_event is considered complete when the associated 95 /// hardware task finishes execution. 96 /// 97 class hard_event : public event { 98 public: 99 hard_event(clover::command_queue &q, cl_command_type command, 100 std::vector<clover::event *> deps, __anon34382cd20102(event &)101 action action = [](event &){}); 102 ~hard_event(); 103 104 virtual cl_int status() const; 105 virtual cl_command_queue queue() const; 106 virtual cl_command_type command() const; 107 virtual void wait() const; 108 109 friend class ::_cl_command_queue; 110 111 private: 112 virtual void fence(pipe_fence_handle *fence); 113 114 clover::command_queue &__queue; 115 cl_command_type __command; 116 pipe_fence_handle *__fence; 117 }; 118 119 /// 120 /// Class that represents a software event. 121 /// 122 /// A soft_event is not associated with any specific hardware task 123 /// or command queue. It's considered complete as soon as all its 124 /// dependencies finish execution. 125 /// 126 class soft_event : public event { 127 public: 128 soft_event(clover::context &ctx, std::vector<clover::event *> deps, __anon34382cd20202(event &)129 bool trigger, action action = [](event &){}); 130 131 virtual cl_int status() const; 132 virtual cl_command_queue queue() const; 133 virtual cl_command_type command() const; 134 virtual void wait() const; 135 }; 136 } 137 138 #endif 139