kc3-lang/angle/src/libANGLE/CLBitField.h

• Show log

  Commit

• Hash : c8dc7c08
  Author :
  Date : 2025-02-13T16:35:05
  

  CL: Fix typo in cl::BitField's exclude() routine
  
  Ignored passed "other" param.
  
  Bug: angleproject:42266936
  Change-Id: Ia616bc7e2d1bfbdd39ed22221157b6aca5529ed2
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6265705
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/CLBitField.h

• //
  // 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.
  //
  // CLBitField.h: A bit field class that encapsulates the cl_bitfield type.
  
  #ifndef LIBANGLE_CLBITFIELD_H_
  #define LIBANGLE_CLBITFIELD_H_
  
  #include <angle_cl.h>
  #include <ostream>
  
  namespace cl
  {
  
  class BitField
  {
    public:
      BitField() noexcept : mBits(0u) {}
      explicit BitField(cl_bitfield bits) noexcept : mBits(bits) {}
  
      BitField &operator=(cl_bitfield bits)
      {
          mBits = bits;
          return *this;
      }
  
      bool operator==(cl_bitfield bits) const { return mBits == bits; }
      bool operator!=(cl_bitfield bits) const { return mBits != bits; }
      bool operator==(const BitField &other) const { return mBits == other.mBits; }
      bool operator!=(const BitField &other) const { return mBits != other.mBits; }
  
      cl_bitfield get() const { return mBits; }
  
      bool intersects(cl_bitfield bits) const { return (mBits & bits) != 0u; }
      bool intersects(const BitField &other) const { return (mBits & other.mBits) != 0u; }
      bool excludes(cl_bitfield bits) const { return !intersects(bits); }
      bool excludes(const BitField &other) const { return !intersects(other); }
  
      bool hasOtherBitsThan(cl_bitfield bits) const { return (mBits & ~bits) != 0u; }
      bool hasOtherBitsThan(const BitField &other) const { return (mBits & ~other.mBits) != 0u; }
  
      bool areMutuallyExclusive(cl_bitfield bits1, cl_bitfield bits2) const
      {
          return (intersects(bits1) ? 1 : 0) + (intersects(bits2) ? 1 : 0) <= 1;
      }
  
      bool areMutuallyExclusive(cl_bitfield bits1, cl_bitfield bits2, cl_bitfield bits3) const
      {
          return (intersects(bits1) ? 1 : 0) + (intersects(bits2) ? 1 : 0) +
                     (intersects(bits3) ? 1 : 0) <=
                 1;
      }
  
      BitField mask(cl_bitfield bits) const { return BitField(mBits & bits); }
      BitField mask(const BitField &other) const { return BitField(mBits & other.mBits); }
  
      void set(cl_bitfield bits) { mBits |= bits; }
      void set(const BitField &other) { mBits |= other.mBits; }
      void clear(cl_bitfield bits) { mBits &= ~bits; }
      void clear(const BitField &other) { mBits &= ~other.mBits; }
  
    private:
      cl_bitfield mBits;
  };
  
  static_assert(sizeof(BitField) == sizeof(cl_bitfield), "Type size mismatch");
  
  using DeviceType                = BitField;
  using DeviceFpConfig            = BitField;
  using DeviceExecCapabilities    = BitField;
  using DeviceSvmCapabilities     = BitField;
  using CommandQueueProperties    = BitField;
  using DeviceAffinityDomain      = BitField;
  using MemFlags                  = BitField;
  using SVM_MemFlags              = BitField;
  using MemMigrationFlags         = BitField;
  using MapFlags                  = BitField;
  using KernelArgTypeQualifier    = BitField;
  using DeviceAtomicCapabilities  = BitField;
  using DeviceEnqueueCapabilities = BitField;
  
  }  // namespace cl
  
  #endif  // LIBANGLE_CLBITFIELD_H_
  

Download