Announcement

Collapse
No announcement yet.

LLVM Clang 14 Begins Landing Intel AVX-512 FP16 Support

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • LLVM Clang 14 Begins Landing Intel AVX-512 FP16 Support

    Phoronix: LLVM Clang 14 Begins Landing Intel AVX-512 FP16 Support

    Last month Intel began posting the developer documentation around AVX-512 FP16 support coming with Sapphire Rapids and initially accompanied by GCC compiler patches along with LLVM/Clang. While that GNU Compiler Collection support around AVX-512 FP16 has yet to be merged, the LLVM Clang support for this next iteration of AVX-512 has begun landing...

    https://www.phoronix.com/scan.php?pa...ang-AVX512FP16

  • #2
    Sounds cool, but most of software will be compiled with march=generic

    Comment


    • #3
      Originally posted by RedEyed View Post
      Sounds cool, but most of software will be compiled with march=generic
      Since no software exists that uses these extensions, that is not a problem.
      This will only be interesting for deep learning libraries and even then only for inference.

      Comment


      • #4
        i wish someone would start expanding fp capabilities upwards too. if you can make it do fp16 then you could make it do fp128 also, ffs.

        Comment


        • #5
          Originally posted by quaz0r View Post
          i wish someone would start expanding fp capabilities upwards too. if you can make it do fp16 then you could make it do fp128 also, ffs.
          The only question is, why do you need fp128, if it is not supported by most hardware and not declared in C/C++ standards?
          fp16 and bfp16 are only for performance benefits
          Last edited by RedEyed; 18 August 2021, 04:45 AM. Reason: Extended question to be mo clear.

          Comment


          • #6
            Originally posted by RedEyed View Post

            The only question is, why do you need fp128?
            fp16 and bfp16 are only for performance benefits
            just out of curiosity, what degree of awareness do you have that your sort of comment will be given literally 100% of the time in response to someone voicing a desire for > fp64 ? it is quite literally 100%.

            given the fact that "why do you need it" is a disingenuous question, the "only real question" here is why do you and those like you exhibit a need to voice an insistence that there either cannot be a real use case for it, or that someone voicing a desire for it is highly likely to be doing so in error?

            are you aware of the existence of libraries like gmp and mpfr implementing arbitrary precision? do you post to their mailing lists disingenuous questions like "why do you need it?"

            you even answered your own question: performance. anyone making use of larger data types would of course potentially benefit from the obvious performance implications of having a hardware implementation of a larger type.

            Comment


            • #7
              Originally posted by quaz0r View Post

              just out of curiosity, what degree of awareness do you have that your sort of comment will be given literally 100% of the time in response to someone voicing a desire for > fp64 ? it is quite literally 100%.

              given the fact that "why do you need it" is a disingenuous question, the "only real question" here is why do you and those like you exhibit a need to voice an insistence that there either cannot be a real use case for it, or that someone voicing a desire for it is highly likely to be doing so in error?

              are you aware of the existence of libraries like gmp and mpfr implementing arbitrary precision? do you post to their mailing lists disingenuous questions like "why do you need it?"

              you even answered your own question: performance. anyone making use of larger data types would of course potentially benefit from the obvious performance implications of having a hardware implementation of a larger type.
              I'm aware of multiple-precision needs (there is bfloat in ATen, or bignums in open/boring SSL which is something different to float precision), but I didn't hear about concrete libraries you mentioned, thanks.

              I didn't ask "why do anyone need float128?"

              Let me paraphrase to be clear.

              In this post we see that LLVM added feature that is supported by modern CPU.
              But AFAIK, quadro precision is much less common in the existing hardware (please, correct me if I'm wrong) then AVX-512 fp16, therefore implementing float128 data type by LLVM is more likely software implementation, rather than using hardware capabilities.

              In my opinion, LLVM is a compiller, which is supposed to translate code into CPU instructions, but not implementing data types (software implementation) that are not supported by the end hardware the code is translated to.

              Also, there is C/C++ standarts and I don't remember anything about quadro precision, so even if LLVM will implement this, how the code which is written with float128 will be compiled by other compilers?

              So the question is: "Why should LLVM implement float128 datatype, if it is not supported by hardware and it is not declared in C/C++ standarts?"

              Maybe, If quadro precision is already supported on most hardware, then it's really good idea to bring support into compiler, but the question of standardization is still open.

              Last edited by RedEyed; 18 August 2021, 03:33 AM.

              Comment


              • #8
                ah, yeah i simply wish for there to be a hardware implementation. it would be great for my own personal software project, but yeah most people dont currently need it for typical stuff.

                gcc already has __float128 and i imagine clang does then also, but these of course are software implementations.

                Comment


                • #9
                  Originally posted by quaz0r View Post
                  ah, yeah i simply wish for there to be a hardware implementation. it would be great for my own personal software project, but yeah most people dont currently need it for typical stuff.

                  gcc already has __float128 and i imagine clang does then also, but these of course are software implementations.
                  Good to know we understood each other

                  Comment

                  Working...
                  X