Hi Carter, I would strongly advise you against this direction. I’m aware of two directions that existing languages go in defining min/max operations: - IEEE 754, C, Fortran, Matlab, OpenCL, and HLSL all define it not to propagate NaNs - C++ (std::min/std::max) and OpenGL define it in the trinary operator manner: (a < b) ? a : b What you’re proposing does not match any existing languages that I’m aware of, and seems likely to hamper cross-language portability for you in the future. More generally, I don’t see a compelling reason for LLVM to add intrinsic support for the version you’re proposing. Your choice can easily be expanded into IR, and does not have the wide hardware support (particularly in GPUs) that the IEEE version does. —Owen> On Aug 18, 2014, at 12:00 PM, Carter Schonwald <carter.schonwald at gmail.com> wrote: > > would it be in scope to have intrinsics analogues for fmin/fmax that return Nan if either arg is a nan? > Julia Lang and GHC Haskell are both likely to change their definitions of min/max on floats/doubles to return nan if either arg is Nan. > See here <https://github.com/JuliaLang/julia/issues/7866> for the julia lang discussion, and I'm amidst putting together the analogous propose for GHC Haskell. > > My understanding is the NAN evading semantics of fmin/fmax in the IEEE spec are motivated by using NaN to encode "this data is missing" rather than the more common "this is the result of an erroneous computation". Granted, such an alternative nan returning fmin/fmax can be written a derived llvm operation too, but they could just as easily benefit from llvm integration. > > I hope this suggestion/question is in scope for this thread, if not I appologize for jumping in. > > thanks! > -Carter > > > On Mon, Aug 18, 2014 at 1:00 PM, Owen Anderson <resistor at mac.com <mailto:resistor at mac.com>> wrote: > This is a problem with all floating point folding, not just with these operations. What Matt is proposing is consistent with how we fold other libm intrinsics. > > —Owen > >> On Aug 18, 2014, at 1:22 AM, Mueller-Roemer, Johannes Sebastian <Johannes.Sebastian.Mueller-Roemer at igd.fraunhofer.de <mailto:Johannes.Sebastian.Mueller-Roemer at igd.fraunhofer.de>> wrote: >> >> Wouldn’t it be better to use the target’s implementation (if there is one) instead of generically using one option for constant folding? Otherwise target behavior and constant folded behavior would differ, which should be avoided if possible IMO. >> >> -- >> Johannes S. Mueller-Roemer, MSc >> Wiss. Mitarbeiter - Interactive Engineering Technologies (IET) >> >> Fraunhofer-Institut für Graphische Datenverarbeitung IGD >> Fraunhoferstr. 5 | 64283 Darmstadt | Germany >> Tel +49 6151 155-606 <tel:%2B49%206151%20155-606> | Fax +49 6151 155-139 <tel:%2B49%206151%20155-139> >> johannes.mueller-roemer at igd.fraunhofer.de <mailto:johannes.mueller-roemer at igd.fraunhofer.de> | www.igd.fraunhofer.de <http://www.igd.fraunhofer.de/> >> >> From: llvmdev-bounces at cs.uiuc.edu <mailto:llvmdev-bounces at cs.uiuc.edu> [mailto:llvmdev-bounces at cs.uiuc.edu <mailto:llvmdev-bounces at cs.uiuc.edu>] On Behalf Of Stephen Canon >> Sent: Thursday, August 14, 2014 18:03 >> To: Matt Arsenault >> Cc: llvm-commits; LLVM Developers Mailing List >> Subject: Re: [LLVMdev] [PATCH][RFC]: Add fmin/fmax intrinsics >> >> … actually, now that I’m able double-check this, I’m quite surprised to find that we didn’t define fmax(+0,–0) in IEEE–754, which says [paraphrased]: >> >> minNum(x,y) is x if x < y, y if y < x, and the number if one is a number and the other is NaN. Otherwise, it is either x or y (this means results might differ among implementations). >> >> So I think your proposed semantics are perfectly reasonable. >> >> – Steve >> >> On Aug 14, 2014, at 10:55 AM, Steve Canon <scanon at apple.com <mailto:scanon at apple.com>> wrote: >> >> I have no position on whether or not these should be added, but if they are they should match the IEEE 754 semantics, which fully specify all of these details. >> >> (Signaling NaNs could still be left unspecified as they're optional in IEEE-754). >> >> - Steve >> >> Sent from my iPhone >> >> >> On Aug 13, 2014, at 7:38 PM, Matt Arsenault <arsenm2 at gmail.com <mailto:arsenm2 at gmail.com>> wrote: >> >> Hi, >> >> I’d like to re-propose adding intrinsics for fmin / fmax. These can be used to implement the equivalent libm functions as defined in C99 and OpenCL, which R600 and AArch64 at least have instructions with the same semantics. This is not equivalent to a simple fcmp + select due to its handling of NaNs. >> >> This has been proposed before, but never delivered (http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-December/057128.html <http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-December/057128.html>) >> >> To summarize: >> 1. If either operand is a NaN, returns the other operand >> 2. If both operands are NaN, returns NaN >> 3. If the operands are equal, returns a value that will compare equal to both arguments >> 4. In the normal case, returns the smaller / larger operand >> 5. Ignore what to do for signaling NaNs, since that’s what the rest of LLVM does currently anyway >> >> - Handling of fmin/fmax (+/- 0.0, +/- 0.0) >> Point 3 is worded as such because this doesn’t seem particularly well specified by any standard I’ve looked at. The most explicit mention of this I’ve found is a footnote in C99 that “Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, 0.0) would return +0; however, implementation in software might be impractical.” It doesn’t really state what the expected behavior is. glibc and OS X’s libc disagree on the (+0, -0) and (-0, +0) cases. To resolve this, the semantics of the intrinsic will be that either will be OK as long as the result compares equal. >> >> For the purposes of constant folding, I’ve tried to follow the literal wording which was most explicit for the expected result from OpenCL (http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/fmin.html <http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/fmin.html>) and taking the comparison +/-0.0 < +/-0.0 will fail. >> >> This means the constant folded results will be: >> fmin(0.0, 0.0) = 0.0 >> fmin(0.0, -0.0) = 0.0 >> fmin(-0.0, 0.0) = -0.0 >> fmin(-0.0, -0.0) = -0.0 >> >> Other options would be to always use +0.0, or to be sensitive to the sign and claim -0.0 is less than 0.0. >> >> <0001-Add-fmin-fmax-intrinsics.patch> >> <0002-Add-basic-fmin-fmax-instcombines.patch> >> <0003-Fold-fmin-fmax-with-infinities.patch> >> <0004-Move-fmin-fmax-constant-folding-logic-into-APFloat.patch> >> >> _______________________________________________ >> LLVM Developers mailing list >> LLVMdev at cs.uiuc.edu <mailto:LLVMdev at cs.uiuc.edu> http://llvm.cs.uiuc.edu <http://llvm.cs.uiuc.edu/> >> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev <http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev> > > _______________________________________________ > LLVM Developers mailing list > LLVMdev at cs.uiuc.edu <mailto:LLVMdev at cs.uiuc.edu> http://llvm.cs.uiuc.edu <http://llvm.cs.uiuc.edu/> > http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev <http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev> > >-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20140818/e3322f7f/attachment.html>
good point, no compiler backend intrinsic support is need. on the IEEE front, the motivation for the nan properties in the standard for fmin and fmax are for the "missing data " interpretation right? This choice does make sense for languages which don't have a more direct way of expressing missing data (such as option types!). the if based compare version does indeed match what many cpus seem to provide. on a higher level language front, if nans only represent erroneous computations rather than missing data, what semantic arguments are there for providing the IEEE min or the "if <" min as the language's min on floats, aside from "other languages do it that way"? On Mon, Aug 18, 2014 at 3:32 PM, Owen Anderson <resistor at mac.com> wrote:> Hi Carter, > > I would strongly advise you against this direction. I’m aware of two > directions that existing languages go in defining min/max operations: > > - IEEE 754, C, Fortran, Matlab, OpenCL, and HLSL all define it not to > propagate NaNs > - C++ (std::min/std::max) and OpenGL define it in the trinary operator > manner: (a < b) ? a : b > > What you’re proposing does not match any existing languages that I’m aware > of, and seems likely to hamper cross-language portability for you in the > future. > > More generally, I don’t see a compelling reason for LLVM to add intrinsic > support for the version you’re proposing. Your choice can easily be > expanded into IR, and does not have the wide hardware support (particularly > in GPUs) that the IEEE version does. > > —Owen > > > On Aug 18, 2014, at 12:00 PM, Carter Schonwald <carter.schonwald at gmail.com> > wrote: > > would it be in scope to have intrinsics analogues for fmin/fmax that > return Nan if either arg is a nan? > Julia Lang and GHC Haskell are both likely to change their definitions of > min/max on floats/doubles to return nan if either arg is Nan. > See here <https://github.com/JuliaLang/julia/issues/7866> for the julia > lang discussion, and I'm amidst putting together the analogous propose for > GHC Haskell. > > My understanding is the NAN evading semantics of fmin/fmax in the IEEE > spec are motivated by using NaN to encode "this data is missing" rather > than the more common "this is the result of an erroneous computation". > Granted, such an alternative nan returning fmin/fmax can be written a > derived llvm operation too, but they could just as easily benefit from llvm > integration. > > I hope this suggestion/question is in scope for this thread, if not I > appologize for jumping in. > > thanks! > -Carter > > > On Mon, Aug 18, 2014 at 1:00 PM, Owen Anderson <resistor at mac.com> wrote: > >> This is a problem with all floating point folding, not just with these >> operations. What Matt is proposing is consistent with how we fold other >> libm intrinsics. >> >> —Owen >> >> On Aug 18, 2014, at 1:22 AM, Mueller-Roemer, Johannes Sebastian < >> Johannes.Sebastian.Mueller-Roemer at igd.fraunhofer.de> wrote: >> >> Wouldn’t it be better to use the target’s implementation (if there is >> one) instead of generically using one option for constant folding? >> Otherwise target behavior and constant folded behavior would differ, which >> should be avoided if possible IMO. >> >> -- >> Johannes S. Mueller-Roemer, MSc >> Wiss. Mitarbeiter - Interactive Engineering Technologies (IET) >> >> Fraunhofer-Institut für Graphische Datenverarbeitung IGD >> Fraunhoferstr. 5 | 64283 Darmstadt | Germany >> Tel +49 6151 155-606 | Fax +49 6151 155-139 >> johannes.mueller-roemer at igd.fraunhofer.de | www.igd.fraunhofer.de >> >> *From:* llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu >> <llvmdev-bounces at cs.uiuc.edu>] *On Behalf Of *Stephen Canon >> *Sent:* Thursday, August 14, 2014 18:03 >> *To:* Matt Arsenault >> *Cc:* llvm-commits; LLVM Developers Mailing List >> *Subject:* Re: [LLVMdev] [PATCH][RFC]: Add fmin/fmax intrinsics >> >> … actually, now that I’m able double-check this, I’m quite surprised to >> find that we didn’t define fmax(+0,–0) in IEEE–754, which says >> [paraphrased]: >> >> *minNum*(x,y) is x if x < y, y if y < x, and the number if >> one is a number and the other is NaN. Otherwise, it is either x or y (this >> means results might differ among implementations). >> >> So I think your proposed semantics are perfectly reasonable. >> >> – Steve >> >> >> On Aug 14, 2014, at 10:55 AM, Steve Canon <scanon at apple.com> wrote: >> >> I have no position on whether or not these should be added, but if they >> are they should match the IEEE 754 semantics, which fully specify all of >> these details. >> >> (Signaling NaNs could still be left unspecified as they're optional in >> IEEE-754). >> >> - Steve >> >> Sent from my iPhone >> >> >> On Aug 13, 2014, at 7:38 PM, Matt Arsenault <arsenm2 at gmail.com> wrote: >> >> Hi, >> >> I’d like to re-propose adding intrinsics for fmin / fmax. These can be >> used to implement the equivalent libm functions as defined in C99 and >> OpenCL, which R600 and AArch64 at least have instructions with the same >> semantics. This is not equivalent to a simple fcmp + select due to its >> handling of NaNs. >> >> This has been proposed before, but never delivered ( >> http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-December/057128.html) >> >> To summarize: >> 1. If either operand is a NaN, returns the other operand >> 2. If both operands are NaN, returns NaN >> 3. If the operands are equal, returns a value that will compare equal to >> both arguments >> 4. In the normal case, returns the smaller / larger operand >> 5. Ignore what to do for signaling NaNs, since that’s what the rest of >> LLVM does currently anyway >> >> - Handling of fmin/fmax (+/- 0.0, +/- 0.0) >> Point 3 is worded as such because this doesn’t seem particularly well >> specified by any standard I’ve looked at. The most explicit mention of this >> I’ve found is a footnote in C99 that “Ideally, fmax would be sensitive to >> the sign of zero, for example fmax(-0.0, 0.0) would return +0; however, >> implementation in software might be impractical.” It doesn’t really state >> what the expected behavior is. glibc and OS X’s libc disagree on the (+0, >> -0) and (-0, +0) cases. To resolve this, the semantics of the intrinsic >> will be that either will be OK as long as the result compares equal. >> >> For the purposes of constant folding, I’ve tried to follow the literal >> wording which was most explicit for the expected result from OpenCL ( >> http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/fmin.html) and >> taking the comparison +/-0.0 < +/-0.0 will fail. >> >> This means the constant folded results will be: >> fmin(0.0, 0.0) = 0.0 >> fmin(0.0, -0.0) = 0.0 >> fmin(-0.0, 0.0) = -0.0 >> fmin(-0.0, -0.0) = -0.0 >> >> Other options would be to always use +0.0, or to be sensitive to the sign >> and claim -0.0 is less than 0.0. >> >> <0001-Add-fmin-fmax-intrinsics.patch> >> <0002-Add-basic-fmin-fmax-instcombines.patch> >> <0003-Fold-fmin-fmax-with-infinities.patch> >> <0004-Move-fmin-fmax-constant-folding-logic-into-APFloat.patch> >> >> >> _______________________________________________ >> LLVM Developers mailing list >> LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu >> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev >> >> >> >> _______________________________________________ >> LLVM Developers mailing list >> LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu >> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev >> >> > >-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20140818/b0980845/attachment.html>
On Mon, Aug 18, 2014 at 12:32 PM, Owen Anderson <resistor at mac.com> wrote:> Hi Carter, > > I would strongly advise you against this direction. I’m aware of two > directions that existing languages go in defining min/max operations: > > - IEEE 754, C, Fortran, Matlab, OpenCL, and HLSL all define it not to > propagate NaNs > - C++ (std::min/std::max) and OpenGL define it in the trinary operator > manner: (a < b) ? a : b > > What you’re proposing does not match any existing languages that I’m aware > of, and seems likely to hamper cross-language portability for you in the > future. >At a quick glance, I found JavaScript [0] and Java [1] both have a min and max that propagate NaN. [0] http://people.mozilla.org/~jorendorff/es6-draft.html#sec-math.max [1] http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#max%28double,%20double%29> More generally, I don’t see a compelling reason for LLVM to add intrinsic > support for the version you’re proposing. Your choice can easily be > expanded into IR, and does not have the wide hardware support (particularly > in GPUs) that the IEEE version does. >The IEEE version can also be expanded in LLVM IR. And for GPUs, many GPU input languages leave the behavior on NaN unspecified, so it's not obviously the best guide. Consider also this: The IEEE version exists within a spec where it's assumed that programmers have elaborate access to information about floating-point exceptions. In practice, programming languages and environments have not been able to reliably deliver this level of access. NaN is one of the few ways left to determine whether an exception has occurred (and even NaN isn't always enough), and so the motivation for NaN propagation in practice may be greater than what it was in the IEEE spec. Dan> > —Owen > > > On Aug 18, 2014, at 12:00 PM, Carter Schonwald <carter.schonwald at gmail.com> > wrote: > > would it be in scope to have intrinsics analogues for fmin/fmax that > return Nan if either arg is a nan? > Julia Lang and GHC Haskell are both likely to change their definitions of > min/max on floats/doubles to return nan if either arg is Nan. > See here <https://github.com/JuliaLang/julia/issues/7866> for the julia > lang discussion, and I'm amidst putting together the analogous propose for > GHC Haskell. > > My understanding is the NAN evading semantics of fmin/fmax in the IEEE > spec are motivated by using NaN to encode "this data is missing" rather > than the more common "this is the result of an erroneous computation". > Granted, such an alternative nan returning fmin/fmax can be written a > derived llvm operation too, but they could just as easily benefit from llvm > integration. > > I hope this suggestion/question is in scope for this thread, if not I > appologize for jumping in. > > thanks! > -Carter > > > On Mon, Aug 18, 2014 at 1:00 PM, Owen Anderson <resistor at mac.com> wrote: > >> This is a problem with all floating point folding, not just with these >> operations. What Matt is proposing is consistent with how we fold other >> libm intrinsics. >> >> —Owen >> >> On Aug 18, 2014, at 1:22 AM, Mueller-Roemer, Johannes Sebastian < >> Johannes.Sebastian.Mueller-Roemer at igd.fraunhofer.de> wrote: >> >> Wouldn’t it be better to use the target’s implementation (if there is >> one) instead of generically using one option for constant folding? >> Otherwise target behavior and constant folded behavior would differ, which >> should be avoided if possible IMO. >> >> -- >> Johannes S. Mueller-Roemer, MSc >> Wiss. Mitarbeiter - Interactive Engineering Technologies (IET) >> >> Fraunhofer-Institut für Graphische Datenverarbeitung IGD >> Fraunhoferstr. 5 | 64283 Darmstadt | Germany >> Tel +49 6151 155-606 | Fax +49 6151 155-139 >> johannes.mueller-roemer at igd.fraunhofer.de | www.igd.fraunhofer.de >> >> *From:* llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu >> <llvmdev-bounces at cs.uiuc.edu>] *On Behalf Of *Stephen Canon >> *Sent:* Thursday, August 14, 2014 18:03 >> *To:* Matt Arsenault >> *Cc:* llvm-commits; LLVM Developers Mailing List >> *Subject:* Re: [LLVMdev] [PATCH][RFC]: Add fmin/fmax intrinsics >> >> … actually, now that I’m able double-check this, I’m quite surprised to >> find that we didn’t define fmax(+0,–0) in IEEE–754, which says >> [paraphrased]: >> >> *minNum*(x,y) is x if x < y, y if y < x, and the number if >> one is a number and the other is NaN. Otherwise, it is either x or y (this >> means results might differ among implementations). >> >> So I think your proposed semantics are perfectly reasonable. >> >> – Steve >> >> >> On Aug 14, 2014, at 10:55 AM, Steve Canon <scanon at apple.com> wrote: >> >> I have no position on whether or not these should be added, but if they >> are they should match the IEEE 754 semantics, which fully specify all of >> these details. >> >> (Signaling NaNs could still be left unspecified as they're optional in >> IEEE-754). >> >> - Steve >> >> Sent from my iPhone >> >> >> On Aug 13, 2014, at 7:38 PM, Matt Arsenault <arsenm2 at gmail.com> wrote: >> >> Hi, >> >> I’d like to re-propose adding intrinsics for fmin / fmax. These can be >> used to implement the equivalent libm functions as defined in C99 and >> OpenCL, which R600 and AArch64 at least have instructions with the same >> semantics. This is not equivalent to a simple fcmp + select due to its >> handling of NaNs. >> >> This has been proposed before, but never delivered ( >> http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-December/057128.html) >> >> To summarize: >> 1. If either operand is a NaN, returns the other operand >> 2. If both operands are NaN, returns NaN >> 3. If the operands are equal, returns a value that will compare equal to >> both arguments >> 4. In the normal case, returns the smaller / larger operand >> 5. Ignore what to do for signaling NaNs, since that’s what the rest of >> LLVM does currently anyway >> >> - Handling of fmin/fmax (+/- 0.0, +/- 0.0) >> Point 3 is worded as such because this doesn’t seem particularly well >> specified by any standard I’ve looked at. The most explicit mention of this >> I’ve found is a footnote in C99 that “Ideally, fmax would be sensitive to >> the sign of zero, for example fmax(-0.0, 0.0) would return +0; however, >> implementation in software might be impractical.” It doesn’t really state >> what the expected behavior is. glibc and OS X’s libc disagree on the (+0, >> -0) and (-0, +0) cases. To resolve this, the semantics of the intrinsic >> will be that either will be OK as long as the result compares equal. >> >> For the purposes of constant folding, I’ve tried to follow the literal >> wording which was most explicit for the expected result from OpenCL ( >> http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/fmin.html) and >> taking the comparison +/-0.0 < +/-0.0 will fail. >> >> This means the constant folded results will be: >> fmin(0.0, 0.0) = 0.0 >> fmin(0.0, -0.0) = 0.0 >> fmin(-0.0, 0.0) = -0.0 >> fmin(-0.0, -0.0) = -0.0 >> >> Other options would be to always use +0.0, or to be sensitive to the sign >> and claim -0.0 is less than 0.0. >> >> <0001-Add-fmin-fmax-intrinsics.patch> >> <0002-Add-basic-fmin-fmax-instcombines.patch> >> <0003-Fold-fmin-fmax-with-infinities.patch> >> <0004-Move-fmin-fmax-constant-folding-logic-into-APFloat.patch> >> >> >> _______________________________________________ >> LLVM Developers mailing list >> LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu >> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev >> >> >> >> _______________________________________________ >> LLVM Developers mailing list >> LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu >> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev >> >> > > > _______________________________________________ > LLVM Developers mailing list > LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu > http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev > >-------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20140912/2a9f37b1/attachment.html>
> On Sep 12, 2014, at 10:27 AM, Dan Gohman <dan433584 at gmail.com> wrote: > > > More generally, I don’t see a compelling reason for LLVM to add intrinsic support for the version you’re proposing. Your choice can easily be expanded into IR, and does not have the wide hardware support (particularly in GPUs) that the IEEE version does. > > The IEEE version can also be expanded in LLVM IR. And for GPUs, many GPU input languages leave the behavior on NaN unspecified, so it's not obviously the best guide.That’s not generally true. HLSL (DirectX), CUDA, OpenCL, and Metal all have defined semantics for NaNs which include not propagating them through min/max. GLSL (OpenGL) is the odd one out in this area. —Owen -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20140912/a306f3f6/attachment.html>