通过编码是否有任何(非微优化)性能增益
float f1 = 200f / 2
在比较中
float f2 = 200f * 0.5
几年前我的一位教授告诉我,浮点除法比浮点乘法慢,但没有详细说明原因.
这句话适用于现代PC架构吗？
UPDATE1
关于评论,请同时考虑这个案例:
float f1;
float f2 = 2
float f3 = 3;
for( i =0 ; i < 1e8; i++)
{
f1 = (i * f2 + i / f3) * 0.5; //or divide by 2.0f, respectively
}
更新2 从评论中引用:
[我想]知道什么是算法/架构要求导致>除法在硬件上比复制要复杂得多
我想检查boost::variant在我的代码中应用的程序集输出,以便查看哪些中间调用被优化掉了.
当我编译以下示例(使用GCC 5.3 g++ -O3 -std=c++14 -S)时,似乎编译器优化了所有内容并直接返回100:
(...)
main:
.LFB9320:
.cfi_startproc
movl $100, %eax
ret
.cfi_endproc
(...)
#include <boost/variant.hpp>
struct Foo
{
int get() { return 100; }
};
struct Bar
{
int get() { return 999; }
};
using Variant = boost::variant<Foo, Bar>;
int run(Variant v)
{
return boost::apply_visitor([](auto& x){return x.get();}, v);
}
int main()
{
Foo f;
return run(f);
}
但是,完整的程序集输出包含的内容远远超过上面的摘录,对我而言,它看起来永远不会被调用.有没有办法告诉GCC/clang删除所有"噪音"并输出程序运行时实际调用的内容？
完整装配输出:
.file "main1.cpp"
.section .rodata.str1.8,"aMS",@progbits,1
.align 8
.LC0:
.string "/opt/boost/include/boost/variant/detail/forced_return.hpp"
.section .rodata.str1.1,"aMS",@progbits,1
.LC1: …我正在阅读"加速C++".我发现一句话说"有时double执行速度比floatC++ 快".读完句子后,我感到困惑float和double工作.请向我解释这一点.
在长时间搜索性能错误后,我读到了非正规浮点值.
显然,非规范化的浮点值可能是主要的性能问题,如此问题所示: 为什么将0.1f更改为0会使性能降低10倍？
我有一个Intel Core 2 Duo,我正在使用gcc进行编译-O2.
那我该怎么办？我可以以某种方式指示g ++避免非正规值吗？如果没有,我可以以某种方式测试一个float是否是非正规的？
如何计算int的百分之几？
例如,我想从数字中得到30%,如果我将使用这个代码示例,我会得到错误的答案:
int number = 250;
int result = (number / 100) * 30;
结果将是60,真正的答案是75,有没有办法计算它？
我有一个如下函数,它被多次调用,这使我的程序运行缓慢.有没有办法优化它？例如,使用SIMD指令或其他技术.getray()函数用于从预先计算的查找表中检索向量-3给定向量-2查询.它在Visual-studio-2013中编译,目标配置是x64机器.
顺便说一句,使用OpenMP已经优化了多次调用此函数的for循环.
非常感谢你.
bool warpPlanarHomography(
const Eigen::Matrix3d& H_camera2_camera1
, const cv::Mat& image1
, const cv::Mat& image2
, FisheyeCameraUnified& cam1
, FisheyeCameraUnified& cam2
, const Eigen::Vector2i& patchCenter
, const int patchSize
, Eigen::Matrix<unsigned char, 7, 7>& patch1)
{
const int patchSize_2 = 3;
for (int v = 0; v < patchSize; ++v) // row
{
for (int u = 0; u < patchSize; ++u)
{
Eigen::Vector2i p1 = Eigen::Vector2i(u - patchSize_2, v - patchSize_2).cast<int>() + patchCenter;
if (p1(0, 0) < 0 …我进行了一些基准测试,以比较双打和浮动性能.看到双打比浮球要快得多,我感到非常惊讶.
我看到了一些关于这方面的讨论,例如:
他们中的大多数人表示,由于双精度优化等原因,双重和浮动性能可能相似.但是当我使用双打时我看到了x2的性能提升 !! 这怎么可能？最糟糕的是,我使用的是32位机器,根据一些帖子的说法,这些机器预计会更好地用于花车......
我使用C#来精确地检查它,但我发现类似的C++实现具有类似的行为.
代码我用来检查它:
static void Main(string[] args)
{
double[,] doubles = new double[64, 64];
float[,] floats = new float[64, 64];
System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
s.Restart();
CalcDoubles(doubles);
s.Stop();
long doubleTime = s.ElapsedMilliseconds;
s.Restart();
CalcFloats(floats);
s.Stop();
long floatTime = s.ElapsedMilliseconds;
Console.WriteLine("Doubles time: " + doubleTime + " ms");
Console.WriteLine("Floats time: " + floatTime + " ms");
}
private static void CalcDoubles(double[,] arr)
{
unsafe
{
fixed (double* p = arr)
{
for …可能重复:
比c#中的浮点数快一倍？
我编写了简单的基准测试来检查我可以在我的应用程序中将double数据类型更改为多少float.这是我的代码:
// my form:
// one textbox: textbox1 (MultiLine property set to true)
// one button: button1 with event button1_Click
private void button1_Click(object sender, EventArgs e)
{
int num = 10000000;
float[] floats1 = new float[num];
float[] floats2 = new float[num];
float[] floatsr = new float[num]; // array for results
double[] doubles1 = new double[num];
double[] doubles2 = new double[num];
double[] doublesr = new double[num]; // array for results
Stopwatch stw = new Stopwatch(); …我有一个花费太多时间的程序,所以我想稍微优化我的代码.
double到目前为止,我已经为每个变量使用了类型.如果我改为类型float,是否会出现任何性能优势？
在声明float类型的变量时,是否有必要在值的末尾写入f？例如,浮点数= .01和浮点数= 0.01f,这里f是什么意思,它是如何产生任何区别的呢？另外,#include库文件的作用是什么？