kc3-lang/angle/src/compiler/translator/hlsl/AtomicCounterFunctionHLSL.cpp

• Show log

  Commit

• Hash : 9b63700b
  Author :
  Date : 2023-07-11T10:25:40
  

  Translator: Reorganize files
  
  This change makes the translator files more organized by:
  
  - Grouping files that are specific to a certain output under their own
    directory,
  - Moving transformations under tree_ops
  - Removing Direct from metal translation now that that SPIR-V Cross path
    is removed
  
  Bug: angleproject:6394
  Change-Id: Iaf5bb8d5604b84748dece029821b1f77b2813967
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4678780
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/compiler/translator/hlsl/AtomicCounterFunctionHLSL.cpp

• //
  // Copyright 2018 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.
  //
  // AtomicCounterFunctionHLSL: Class for writing implementation of atomic counter functions into HLSL
  // output.
  //
  
  #include "compiler/translator/hlsl/AtomicCounterFunctionHLSL.h"
  
  #include "compiler/translator/Common.h"
  #include "compiler/translator/ImmutableStringBuilder.h"
  #include "compiler/translator/InfoSink.h"
  #include "compiler/translator/IntermNode.h"
  
  namespace sh
  {
  
  namespace
  {
  constexpr ImmutableString kAtomicCounter("atomicCounter");
  constexpr ImmutableString kAtomicCounterIncrement("atomicCounterIncrement");
  constexpr ImmutableString kAtomicCounterDecrement("atomicCounterDecrement");
  constexpr ImmutableString kAtomicCounterBaseName("_acbase_");
  }  // namespace
  
  AtomicCounterFunctionHLSL::AtomicCounterFunctionHLSL(bool forceResolution)
      : mForceResolution(forceResolution)
  {}
  
  ImmutableString AtomicCounterFunctionHLSL::useAtomicCounterFunction(const ImmutableString &name)
  {
      // The largest string that will be create created is "_acbase_increment" or "_acbase_decrement"
      ImmutableStringBuilder hlslFunctionNameSB(kAtomicCounterBaseName.length() +
                                                strlen("increment"));
      hlslFunctionNameSB << kAtomicCounterBaseName;
  
      AtomicCounterFunction atomicMethod;
      if (kAtomicCounter == name)
      {
          atomicMethod = AtomicCounterFunction::LOAD;
          hlslFunctionNameSB << "load";
      }
      else if (kAtomicCounterIncrement == name)
      {
          atomicMethod = AtomicCounterFunction::INCREMENT;
          hlslFunctionNameSB << "increment";
      }
      else if (kAtomicCounterDecrement == name)
      {
          atomicMethod = AtomicCounterFunction::DECREMENT;
          hlslFunctionNameSB << "decrement";
      }
      else
      {
          atomicMethod = AtomicCounterFunction::INVALID;
          UNREACHABLE();
      }
  
      ImmutableString hlslFunctionName(hlslFunctionNameSB);
      mAtomicCounterFunctions[hlslFunctionName] = atomicMethod;
  
      return hlslFunctionName;
  }
  
  void AtomicCounterFunctionHLSL::atomicCounterFunctionHeader(TInfoSinkBase &out)
  {
      for (auto &atomicFunction : mAtomicCounterFunctions)
      {
          out << "uint " << atomicFunction.first
              << "(in RWByteAddressBuffer counter, int address)\n"
                 "{\n"
                 "    uint ret;\n";
  
          switch (atomicFunction.second)
          {
              case AtomicCounterFunction::INCREMENT:
                  out << "    counter.InterlockedAdd(address, 1u, ret);\n";
                  break;
              case AtomicCounterFunction::DECREMENT:
                  out << "    counter.InterlockedAdd(address, 0u - 1u, ret);\n"
                         "    ret -= 1u;\n";  // atomicCounterDecrement is a post-decrement op
                  break;
              case AtomicCounterFunction::LOAD:
                  out << "    ret = counter.Load(address);\n";
                  break;
              default:
                  UNREACHABLE();
                  break;
          }
  
          if (mForceResolution && atomicFunction.second != AtomicCounterFunction::LOAD)
          {
              out << "    if (ret == 0) {\n"
                     "        ret = 0 - ret;\n"
                     "    }\n";
          }
  
          out << "    return ret;\n"
                 "}\n\n";
      }
  }
  
  ImmutableString getAtomicCounterNameForBinding(int binding)
  {
      std::stringstream counterName = sh::InitializeStream<std::stringstream>();
      counterName << kAtomicCounterBaseName << binding;
      return ImmutableString(counterName.str());
  }
  
  }  // namespace sh
  

Download