Hash :
44a5c913
        
        Author :
  
        
        Date :
2021-06-17T09:29:29
        
      
CL: Make CL front end and back end thread-safe Add locking to all mutable variables of the CL objects in the front end and pass-through back end to make them thread-safe. This fixes a crash in a multi-threaded CTS test. Bug: angleproject:6015 Change-Id: I1d6471c851217639411c434c82acd32d14035291 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2967468 Commit-Queue: John Plate <jplate@google.com> Reviewed-by: Cody Northrop <cnorthrop@google.com> Reviewed-by: Jamie Madill <jmadill@chromium.org>
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
//
// Copyright 2021 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// CLCommandQueue.h: Defines the cl::CommandQueue class, which can be used to queue a set of OpenCL
// operations.
#ifndef LIBANGLE_CLCOMMANDQUEUE_H_
#define LIBANGLE_CLCOMMANDQUEUE_H_
#include "libANGLE/CLObject.h"
#include "libANGLE/renderer/CLCommandQueueImpl.h"
#include "common/SynchronizedValue.h"
#include <limits>
namespace cl
{
class CommandQueue final : public _cl_command_queue, public Object
{
  public:
    // Front end entry functions, only called from OpenCL entry points
    cl_int getInfo(CommandQueueInfo name,
                   size_t valueSize,
                   void *value,
                   size_t *valueSizeRet) const;
    cl_int setProperty(CommandQueueProperties properties,
                       cl_bool enable,
                       cl_command_queue_properties *oldProperties);
    cl_int enqueueReadBuffer(cl_mem buffer,
                             cl_bool blockingRead,
                             size_t offset,
                             size_t size,
                             void *ptr,
                             cl_uint numEventsInWaitList,
                             const cl_event *eventWaitList,
                             cl_event *event);
    cl_int enqueueWriteBuffer(cl_mem buffer,
                              cl_bool blockingWrite,
                              size_t offset,
                              size_t size,
                              const void *ptr,
                              cl_uint numEventsInWaitList,
                              const cl_event *eventWaitList,
                              cl_event *event);
    cl_int enqueueReadBufferRect(cl_mem buffer,
                                 cl_bool blockingRead,
                                 const size_t *bufferOrigin,
                                 const size_t *hostOrigin,
                                 const size_t *region,
                                 size_t bufferRowPitch,
                                 size_t bufferSlicePitch,
                                 size_t hostRowPitch,
                                 size_t hostSlicePitch,
                                 void *ptr,
                                 cl_uint numEventsInWaitList,
                                 const cl_event *eventWaitList,
                                 cl_event *event);
    cl_int enqueueWriteBufferRect(cl_mem buffer,
                                  cl_bool blockingWrite,
                                  const size_t *bufferOrigin,
                                  const size_t *hostOrigin,
                                  const size_t *region,
                                  size_t bufferRowPitch,
                                  size_t bufferSlicePitch,
                                  size_t hostRowPitch,
                                  size_t hostSlicePitch,
                                  const void *ptr,
                                  cl_uint numEventsInWaitList,
                                  const cl_event *eventWaitList,
                                  cl_event *event);
    cl_int enqueueCopyBuffer(cl_mem srcBuffer,
                             cl_mem dstBuffer,
                             size_t srcOffset,
                             size_t dstOffset,
                             size_t size,
                             cl_uint numEventsInWaitList,
                             const cl_event *eventWaitList,
                             cl_event *event);
    cl_int enqueueCopyBufferRect(cl_mem srcBuffer,
                                 cl_mem dstBuffer,
                                 const size_t *srcOrigin,
                                 const size_t *dstOrigin,
                                 const size_t *region,
                                 size_t srcRowPitch,
                                 size_t srcSlicePitch,
                                 size_t dstRowPitch,
                                 size_t dstSlicePitch,
                                 cl_uint numEventsInWaitList,
                                 const cl_event *eventWaitList,
                                 cl_event *event);
    cl_int enqueueFillBuffer(cl_mem buffer,
                             const void *pattern,
                             size_t patternSize,
                             size_t offset,
                             size_t size,
                             cl_uint numEventsInWaitList,
                             const cl_event *eventWaitList,
                             cl_event *event);
    void *enqueueMapBuffer(cl_mem buffer,
                           cl_bool blockingMap,
                           MapFlags mapFlags,
                           size_t offset,
                           size_t size,
                           cl_uint numEventsInWaitList,
                           const cl_event *eventWaitList,
                           cl_event *event,
                           cl_int &errorCode);
    cl_int enqueueReadImage(cl_mem image,
                            cl_bool blockingRead,
                            const size_t *origin,
                            const size_t *region,
                            size_t rowPitch,
                            size_t slicePitch,
                            void *ptr,
                            cl_uint numEventsInWaitList,
                            const cl_event *eventWaitList,
                            cl_event *event);
    cl_int enqueueWriteImage(cl_mem image,
                             cl_bool blockingWrite,
                             const size_t *origin,
                             const size_t *region,
                             size_t inputRowPitch,
                             size_t inputSlicePitch,
                             const void *ptr,
                             cl_uint numEventsInWaitList,
                             const cl_event *eventWaitList,
                             cl_event *event);
    cl_int enqueueCopyImage(cl_mem srcImage,
                            cl_mem dstImage,
                            const size_t *srcOrigin,
                            const size_t *dstOrigin,
                            const size_t *region,
                            cl_uint numEventsInWaitList,
                            const cl_event *eventWaitList,
                            cl_event *event);
    cl_int enqueueFillImage(cl_mem image,
                            const void *fillColor,
                            const size_t *origin,
                            const size_t *region,
                            cl_uint numEventsInWaitList,
                            const cl_event *eventWaitList,
                            cl_event *event);
    cl_int enqueueCopyImageToBuffer(cl_mem srcImage,
                                    cl_mem dstBuffer,
                                    const size_t *srcOrigin,
                                    const size_t *region,
                                    size_t dstOffset,
                                    cl_uint numEventsInWaitList,
                                    const cl_event *eventWaitList,
                                    cl_event *event);
    cl_int enqueueCopyBufferToImage(cl_mem srcBuffer,
                                    cl_mem dstImage,
                                    size_t srcOffset,
                                    const size_t *dstOrigin,
                                    const size_t *region,
                                    cl_uint numEventsInWaitList,
                                    const cl_event *eventWaitList,
                                    cl_event *event);
    void *enqueueMapImage(cl_mem image,
                          cl_bool blockingMap,
                          MapFlags mapFlags,
                          const size_t *origin,
                          const size_t *region,
                          size_t *imageRowPitch,
                          size_t *imageSlicePitch,
                          cl_uint numEventsInWaitList,
                          const cl_event *eventWaitList,
                          cl_event *event,
                          cl_int &errorCode);
    cl_int enqueueUnmapMemObject(cl_mem memobj,
                                 void *mappedPtr,
                                 cl_uint numEventsInWaitList,
                                 const cl_event *eventWaitList,
                                 cl_event *event);
    cl_int enqueueMigrateMemObjects(cl_uint numMemObjects,
                                    const cl_mem *memObjects,
                                    MemMigrationFlags flags,
                                    cl_uint numEventsInWaitList,
                                    const cl_event *eventWaitList,
                                    cl_event *event);
    cl_int enqueueNDRangeKernel(cl_kernel kernel,
                                cl_uint workDim,
                                const size_t *globalWorkOffset,
                                const size_t *globalWorkSize,
                                const size_t *localWorkSize,
                                cl_uint numEventsInWaitList,
                                const cl_event *eventWaitList,
                                cl_event *event);
    cl_int enqueueTask(cl_kernel kernel,
                       cl_uint numEventsInWaitList,
                       const cl_event *eventWaitList,
                       cl_event *event);
    cl_int enqueueNativeKernel(UserFunc userFunc,
                               void *args,
                               size_t cbArgs,
                               cl_uint numMemObjects,
                               const cl_mem *memList,
                               const void **argsMemLoc,
                               cl_uint numEventsInWaitList,
                               const cl_event *eventWaitList,
                               cl_event *event);
    cl_int enqueueMarkerWithWaitList(cl_uint numEventsInWaitList,
                                     const cl_event *eventWaitList,
                                     cl_event *event);
    cl_int enqueueMarker(cl_event *event);
    cl_int enqueueWaitForEvents(cl_uint numEvents, const cl_event *eventList);
    cl_int enqueueBarrierWithWaitList(cl_uint numEventsInWaitList,
                                      const cl_event *eventWaitList,
                                      cl_event *event);
    cl_int enqueueBarrier();
    cl_int flush();
    cl_int finish();
  public:
    using PropArray = std::vector<cl_queue_properties>;
    static constexpr cl_uint kNoSize = std::numeric_limits<cl_uint>::max();
    ~CommandQueue() override;
    Context &getContext();
    const Context &getContext() const;
    const Device &getDevice() const;
    // Get index of device in the context.
    size_t getDeviceIndex() const;
    CommandQueueProperties getProperties() const;
    bool isOnHost() const;
    bool isOnDevice() const;
    bool hasSize() const;
    cl_uint getSize() const;
    template <typename T = rx::CLCommandQueueImpl>
    T &getImpl() const;
  private:
    CommandQueue(Context &context,
                 Device &device,
                 PropArray &&propArray,
                 CommandQueueProperties properties,
                 cl_uint size,
                 cl_int &errorCode);
    CommandQueue(Context &context,
                 Device &device,
                 CommandQueueProperties properties,
                 cl_int &errorCode);
    const ContextPtr mContext;
    const DevicePtr mDevice;
    const PropArray mPropArray;
    angle::SynchronizedValue<CommandQueueProperties> mProperties;
    const cl_uint mSize = kNoSize;
    const rx::CLCommandQueueImpl::Ptr mImpl;
    friend class Object;
};
inline Context &CommandQueue::getContext()
{
    return *mContext;
}
inline const Context &CommandQueue::getContext() const
{
    return *mContext;
}
inline const Device &CommandQueue::getDevice() const
{
    return *mDevice;
}
inline CommandQueueProperties CommandQueue::getProperties() const
{
    return *mProperties;
}
inline bool CommandQueue::isOnHost() const
{
    return mProperties->isNotSet(CL_QUEUE_ON_DEVICE);
}
inline bool CommandQueue::isOnDevice() const
{
    return mProperties->isSet(CL_QUEUE_ON_DEVICE);
}
inline bool CommandQueue::hasSize() const
{
    return mSize != kNoSize;
}
inline cl_uint CommandQueue::getSize() const
{
    return mSize;
}
template <typename T>
inline T &CommandQueue::getImpl() const
{
    return static_cast<T &>(*mImpl);
}
}  // namespace cl
#endif  // LIBANGLE_CLCOMMANDQUEUE_H_