Operator.h

Show log
Commit

Hash : a6a7842f
Author :
Date : 2018-06-28T08:32:54

ES31: Support atomic functions on D3D11 - Part I

This patch is the first one of the implementation of atomic
functions in D3D11.

There are mainly two differences in the usage of GLSL and HLSL
atomic functions:
1. All GLSL atomic functions have return values, which all
   represent the original value of the shared or ssbo variable;
   while all HLSL atomic functions don't, and the original value
   can be stored in the last parameter of the function call.
2. For HLSL atomic functions, the last parameter that stores the
   original value is optional except for InterlockedExchange and
   InterlockedCompareExchange. Missing original_value in the call
   of InterlockedExchange and InterlockedCompareExchange results
   in a compile error from HLSL compiler.

To handle these differences, we plan to implement the translation
in two steps:
1. Support direct translations from GLSL atomic functions to HLSL
   ones.
Direct translation can only handle the following two situations:
(1) The sentence is a GLSL atomic function call without requesting
    a return value and it is not atomicExchange or atomicCompSwap:
    e.g.
    GLSL: atomicAdd(mem, value);
 -> HLSL: InterlockedAdd(mem, value);
(2) The sentence is a simple assignment expression: its right is
    a GLSL atomic function call and its left is a declared variable.
    e.g.
    GLSL: oldValue = atomicAdd(mem, value);
 -> HLSL: InterlockedAdd(mem, value, oldValue);

2. Support atomic functions in the situations that don't support
   direct translations.
We will modify the intermediate tree to make direct translation work
on all these situations.
e.g.
   atomicExchange(mem, value);
-> int oldValue;
   oldValue = atomicExchange(mem, value);

   int oldValue = atomicAdd(mem, value);
-> int oldValue;
   oldValue = atomicAdd(mem, value);

   return atomicAdd(mem, value);
-> int temp;
   temp = atomicAdd(mem, value);
   return temp;

   for (i = 0; i < atomicAdd(mem, value); ++i)
-> int temp;
   temp = atomicAdd(mem, value);
   for (i = 0; i < temp; ++i)
   {
       ...
       temp = atomicAdd(mem, value);
   }

   int result = isTrue ? atomicAdd(mem, value) : 0;
-> int result;
   if (isTrue)
   {
       result = atomicAdd(mem, value);
   }
   else
   {
       result = 0;
   }

This patch completes Step 1 which mainly focus on the translation
from GLSL atomic functions to HLSL ones.

BUG=angleproject:2682
TEST=angle_end2end_tests

Change-Id: I3b655b6e286dad4fd97f255f7fe87521c94db30c
Reviewed-on: https://chromium-review.googlesource.com/1121835
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>

Download

src/compiler/translator/Operator.h

//
// Copyright (c) 2002-2015 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.
//

#ifndef COMPILER_TRANSLATOR_OPERATOR_H_
#define COMPILER_TRANSLATOR_OPERATOR_H_

//
// Operators used by the high-level (parse tree) representation.
//
enum TOperator
{
    EOpNull,  // if in a node, should only mean a node is still being built

    // Call a function defined in the AST. This might be a user-defined function or a function
    // inserted by an AST transformation.
    EOpCallFunctionInAST,

    // Call an internal helper function with a raw implementation - the implementation can't be
    // subject to AST transformations. Raw functions have a few constraints to keep them compatible
    // with AST traversers:
    // * They should not return arrays.
    // * They should not have out parameters.
    EOpCallInternalRawFunction,

    // Call a built-in function like a texture or image function.
    EOpCallBuiltInFunction,

    //
    // Unary operators
    //

    EOpNegative,
    EOpPositive,
    EOpLogicalNot,
    EOpBitwiseNot,

    EOpPostIncrement,
    EOpPostDecrement,
    EOpPreIncrement,
    EOpPreDecrement,

    EOpArrayLength,

    //
    // binary operations (ones with special GLSL syntax are used in TIntermBinary nodes, others in
    // TIntermAggregate nodes)
    //

    EOpAdd,
    EOpSub,
    EOpMul,
    EOpDiv,
    EOpIMod,

    EOpEqual,
    EOpNotEqual,
    EOpLessThan,
    EOpGreaterThan,
    EOpLessThanEqual,
    EOpGreaterThanEqual,

    EOpEqualComponentWise,
    EOpNotEqualComponentWise,
    EOpLessThanComponentWise,
    EOpLessThanEqualComponentWise,
    EOpGreaterThanComponentWise,
    EOpGreaterThanEqualComponentWise,

    EOpComma,

    EOpVectorTimesScalar,
    EOpVectorTimesMatrix,
    EOpMatrixTimesVector,
    EOpMatrixTimesScalar,
    EOpMatrixTimesMatrix,

    EOpLogicalOr,
    EOpLogicalXor,
    EOpLogicalAnd,

    EOpBitShiftLeft,
    EOpBitShiftRight,

    EOpBitwiseAnd,
    EOpBitwiseXor,
    EOpBitwiseOr,

    EOpIndexDirect,
    EOpIndexIndirect,
    EOpIndexDirectStruct,
    EOpIndexDirectInterfaceBlock,

    //
    // Built-in functions mapped to operators (either unary or with multiple parameters)
    //

    EOpRadians,
    EOpDegrees,
    EOpSin,
    EOpCos,
    EOpTan,
    EOpAsin,
    EOpAcos,
    EOpAtan,

    EOpSinh,
    EOpCosh,
    EOpTanh,
    EOpAsinh,
    EOpAcosh,
    EOpAtanh,

    EOpPow,
    EOpExp,
    EOpLog,
    EOpExp2,
    EOpLog2,
    EOpSqrt,
    EOpInversesqrt,

    EOpAbs,
    EOpSign,
    EOpFloor,
    EOpTrunc,
    EOpRound,
    EOpRoundEven,
    EOpCeil,
    EOpFract,
    EOpMod,
    EOpModf,
    EOpMin,
    EOpMax,
    EOpClamp,
    EOpMix,
    EOpStep,
    EOpSmoothstep,
    EOpIsnan,
    EOpIsinf,

    EOpFloatBitsToInt,
    EOpFloatBitsToUint,
    EOpIntBitsToFloat,
    EOpUintBitsToFloat,

    EOpFrexp,
    EOpLdexp,

    EOpPackSnorm2x16,
    EOpPackUnorm2x16,
    EOpPackHalf2x16,
    EOpUnpackSnorm2x16,
    EOpUnpackUnorm2x16,
    EOpUnpackHalf2x16,

    EOpPackUnorm4x8,
    EOpPackSnorm4x8,
    EOpUnpackUnorm4x8,
    EOpUnpackSnorm4x8,

    EOpLength,
    EOpDistance,
    EOpDot,
    EOpCross,
    EOpNormalize,
    EOpFaceforward,
    EOpReflect,
    EOpRefract,

    EOpDFdx,    // Fragment only, OES_standard_derivatives extension
    EOpDFdy,    // Fragment only, OES_standard_derivatives extension
    EOpFwidth,  // Fragment only, OES_standard_derivatives extension

    EOpMulMatrixComponentWise,
    EOpOuterProduct,
    EOpTranspose,
    EOpDeterminant,
    EOpInverse,

    EOpAny,
    EOpAll,
    EOpLogicalNotComponentWise,

    EOpBitfieldExtract,
    EOpBitfieldInsert,
    EOpBitfieldReverse,
    EOpBitCount,
    EOpFindLSB,
    EOpFindMSB,
    EOpUaddCarry,
    EOpUsubBorrow,
    EOpUmulExtended,
    EOpImulExtended,

    //
    // Branch
    //

    EOpKill,  // Fragment only
    EOpReturn,
    EOpBreak,
    EOpContinue,

    //
    // Constructor
    //

    EOpConstruct,

    //
    // moves
    //

    EOpAssign,
    EOpInitialize,
    EOpAddAssign,
    EOpSubAssign,

    EOpMulAssign,
    EOpVectorTimesMatrixAssign,
    EOpVectorTimesScalarAssign,
    EOpMatrixTimesScalarAssign,
    EOpMatrixTimesMatrixAssign,

    EOpDivAssign,
    EOpIModAssign,
    EOpBitShiftLeftAssign,
    EOpBitShiftRightAssign,
    EOpBitwiseAndAssign,
    EOpBitwiseXorAssign,
    EOpBitwiseOrAssign,

    //  barriers
    EOpBarrier,
    EOpMemoryBarrier,
    EOpMemoryBarrierAtomicCounter,
    EOpMemoryBarrierBuffer,
    EOpMemoryBarrierImage,
    EOpMemoryBarrierShared,
    EOpGroupMemoryBarrier,

    // Atomic functions
    EOpAtomicAdd,
    EOpAtomicMin,
    EOpAtomicMax,
    EOpAtomicAnd,
    EOpAtomicOr,
    EOpAtomicXor,
    EOpAtomicExchange,
    EOpAtomicCompSwap,

    //  Geometry only
    EOpEmitVertex,
    EOpEndPrimitive
};

// Returns the string corresponding to the operator in GLSL
const char *GetOperatorString(TOperator op);

// Say whether or not a binary or unary operation changes the value of a variable.
bool IsAssignment(TOperator op);

// Say whether or not an operator represents an atomic function.
bool IsAtomicFunction(TOperator op);

#endif  // COMPILER_TRANSLATOR_OPERATOR_H_

Download