我一直看到这个常量弹出各种图形头文件
0.0039215689
它似乎与颜色有关吗？
void RDP_G_SETFOGCOLOR(void)
{
Gfx.FogColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
Gfx.FogColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
Gfx.FogColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
Gfx.FogColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
}
void RDP_G_SETBLENDCOLOR(void)
{
Gfx.BlendColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
Gfx.BlendColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
Gfx.BlendColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
Gfx.BlendColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
if(OpenGL.Ext_FragmentProgram && (System.Options & BRDP_COMBINER)) {
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, Gfx.BlendColor.R, …我最近遇到了以下深奥的代码.
int main(){(([](){})());}
按如下方式重新格式化以使其更具可读性:
int main(){
(([](){})()); // Um... what?!?!
}
但我无法理解如何(([](){})())有效的代码.
谷歌对这种全符号搜索没有多大帮助.但它在Visual Studio 2010中编译并且不输出任何内容.没有错误,也没有警告.所以它看起来像有效的代码.
我从未见过任何在Javascript和C函数指针之外如此奇怪的有效代码.
有人可以解释这是如何有效的C++？
The C++ Standard Library (Second Edition)Nicolai Josuttis 在其着作中指出,编译器可以比普通函数更好地优化lambdas.
此外,C++编译器比普通函数更好地优化lambdas.(第213页)
这是为什么？
我认为在内联时不应该有任何差别.我能想到的唯一原因是编译器可能有一个更好的本地上下文与lambdas,这样可以做出更多假设并执行更多优化.
以下代码进入GCC的无限循环:
#include <iostream>
using namespace std;
int main(){
int i = 0x10000000;
int c = 0;
do{
c++;
i += i;
cout << i << endl;
}while (i > 0);
cout << c << endl;
return 0;
}
所以这是交易:有符号整数溢出在技术上是未定义的行为.但是x86上的GCC使用x86整数指令实现整数运算 - 它包含溢出.
因此,我本来期望它包装溢出 - 尽管事实上它是未定义的行为.但事实显然并非如此.那么我错过了什么？
我使用以下方法编译:
~/Desktop$ g++ main.cpp -O2
GCC输出:
~/Desktop$ ./a.out
536870912
1073741824
-2147483648
0
0
0
... (infinite loop)
禁用优化后,没有无限循环且输出正确.Visual Studio也正确编译它并给出以下结果:
正确的输出:
~/Desktop$ g++ main.cpp
~/Desktop$ ./a.out
536870912
1073741824
-2147483648
3
以下是一些其他变体:
i *= 2; // Also …我得到一个512 ^ 3数组,表示模拟的温度分布(用Fortran编写).该数组存储在大小约为1/2G的二进制文件中.我需要知道这个数组的最小值,最大值和平均值,因为我很快就需要了解Fortran代码,我决定试一试,并提出了以下非常简单的例程.
integer gridsize,unit,j
real mini,maxi
double precision mean
gridsize=512
unit=40
open(unit=unit,file='T.out',status='old',access='stream',&
form='unformatted',action='read')
read(unit=unit) tmp
mini=tmp
maxi=tmp
mean=tmp
do j=2,gridsize**3
read(unit=unit) tmp
if(tmp>maxi)then
maxi=tmp
elseif(tmp<mini)then
mini=tmp
end if
mean=mean+tmp
end do
mean=mean/gridsize**3
close(unit=unit)
在我使用的机器上,每个文件大约需要25秒.这让我觉得很长,所以我继续在Python中做了以下事情:
import numpy
mmap=numpy.memmap('T.out',dtype='float32',mode='r',offset=4,\
shape=(512,512,512),order='F')
mini=numpy.amin(mmap)
maxi=numpy.amax(mmap)
mean=numpy.mean(mmap)
现在,我预计这会更快,但我真的被吹走了.在相同条件下只需不到一秒钟.平均值偏离我的Fortran例程发现的那个(我也使用128位浮点运行,所以我不知何故更多地信任它),但仅限于第7位有效数字左右.
numpy怎么这么快？我的意思是你必须查看数组的每个条目才能找到这些值,对吧？我在Fortran程序中做了一件非常愚蠢的事情,因为它花了这么长时间吗？
编辑:
要回答评论中的问题:
iso_fortran_env它提供128位浮点数.编辑2:
我实现了@Alexander Vogt和@casey在他们的答案中提出的建议,它的速度一样快,numpy但现在我有一个精确的问题,因为@Luaan指出我可能会得到.使用32位浮点数组,计算出的平均值sum为20%.干
...
real,allocatable :: tmp (:,:,:)
double precision,allocatable :: tmp2(:,:,:)
...
tmp2=tmp
mean=sum(tmp2)/size(tmp)
...
解决了这个问题但增加了计算时间(不是很多,但显着).有没有更好的方法来解决这个问题？我找不到从文件中直接读单打的方法.怎么numpy避免这个？
感谢目前为止所有的帮助.
这是一个非常有趣的问题,所以让我设置场景.我在国家计算机博物馆工作,我们刚刚设法从1992年开始运行一台Cray Y-MP EL超级计算机,我们真的想看看它有多快!
我们认为最好的方法是编写一个简单的C程序来计算素数,并显示这需要多长时间,然后在快速的现代台式PC上运行程序并比较结果.
我们很快想出了这个代码来计算素数:
#include <stdio.h>
#include <time.h>
void main() {
clock_t start, end;
double runTime;
start = clock();
int i, num = 1, primes = 0;
while (num <= 1000) {
i = 2;
while (i <= num) {
if(num % i == 0)
break;
i++;
}
if (i == num)
primes++;
system("clear");
printf("%d prime numbers calculated\n",primes);
num++;
}
end = clock();
runTime = (end - start) / (double) CLOCKS_PER_SEC;
printf("This machine calculated all %d prime numbers under …我有一个矩阵乘法代码,如下所示:
for(i = 0; i < dimension; i++)
for(j = 0; j < dimension; j++)
for(k = 0; k < dimension; k++)
C[dimension*i+j] += A[dimension*i+k] * B[dimension*k+j];
这里,矩阵的大小由表示dimension.现在,如果矩阵的大小是2000,运行这段代码需要147秒,而如果矩阵的大小是2048,则需要447秒.所以虽然差别没有.乘法是(2048*2048*2048)/(2000*2000*2000)= 1.073,时间上的差异是447/147 = 3.有人可以解释为什么会发生这种情况吗？我预计它会线性扩展,但这不会发生.我不是要尝试制作最快的矩阵乘法代码,只是试图理解它为什么会发生.
规格:AMD Opteron双核节点(2.2GHz),2G RAM,gcc v 4.5.0
程序编译为 gcc -O3 simple.c
我也在英特尔的icc编译器上运行了这个,并看到了类似的结果.
编辑:
正如评论/答案中所建议的那样,我运行了维度= 2060的代码,需要145秒.
继承完整的计划:
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
/* change dimension size as needed */
const int dimension = 2048;
struct timeval tv;
double timestamp()
{
double t;
gettimeofday(&tv, NULL);
t = tv.tv_sec + (tv.tv_usec/1000000.0); …我一直试图通过计算一个使用以下代码对数组元素进行扩展和求和的例程来了解在L1缓存与内存中使用数组的影响(我知道我应该将结果缩放为' a'在最后;关键是在循环中同时进行乘法和加法 - 到目前为止,编译器还没有想出要将'a'分解出来):
double sum(double a,double* X,int size)
{
double total = 0.0;
for(int i = 0; i < size; ++i)
{
total += a*X[i];
}
return total;
}
#define KB 1024
int main()
{
//Approximately half the L1 cache size of my machine
int operand_size = (32*KB)/(sizeof(double)*2);
printf("Operand size: %d\n", operand_size);
double* X = new double[operand_size];
fill(X,operand_size);
double seconds = timer();
double result;
int n_iterations = 100000;
for(int i = 0; i < n_iterations; ++i)
{
result = …我想写一个小的低级程序.对于它的某些部分,我将需要使用汇编语言,但其余代码将使用C/C++编写.
那么,如果我使用GCC将C/C++与汇编代码混合在一起,我是否需要使用AT&T语法,还是可以使用Intel语法？或者你如何以其他方式混合使用C/C++和asm(intel语法)？
我意识到也许我没有选择,必须使用AT&T语法,但我想确定..
如果结果没有选择,我可以在哪里找到有关AT&T语法的完整/官方文档？
谢谢!
我是C++样式转换的新手,我担心使用C++样式转换会破坏我的应用程序的性能,因为我的中断服务例程中有一个实时关键的截止日期.
我听说有些演员甚至会抛出异常!
我想使用C++样式转换,因为它会使我的代码更"强大".但是,如果有任何性能损失,那么我可能不会使用C++样式转换,而是会花更多时间测试使用C风格转换的代码.
有没有人做过任何严格的测试/分析来比较C++风格的演员阵容和C风格演员阵容的表现？
你有什么结果？
你得出了什么结论？