小编cru*_*ear的帖子

让我们从描述发生了什么开始:

我在Windows上玩SDL2库.我可以使用它编译程序,当我运行.exe时它工作得很好.当我尝试使用GDB调试它时出现问题 - 当代码进入SDL_Init或SDL_OpenAudio函数(可能创建新线程),GDB停止,显示"程序接收信号？,未知信号"消息,并且当我恢复执行时程序崩溃.

显然,GDB(https://www.mail-archive.com/cygwin@cygwin.com/msg149735.html)中存在与线程命名相关的错误,应该在GDB版本7.11.1-1中修复.

起初我使用GCC 5.1.0(TDM)和GDB 7.6.1,所以我决定更新到更新的版本.看起来大约两年前TDM没有提供任何更新,所以我安装了MinGW-w64(我现在不记得了,但它可能是GDB的7.11版本).没有帮助,GDB stil崩溃了.

接下来我搜索了更新版本的GDB,找到了7.12(www dot equation dot com/servlet/equation.cmd？fa = gdb).也没有工作,也许修复没有达到这个版本.

显然这个bug应该只存在于x86版本的GDB中,所以我安装了x64版本的TDM(GCC 5.1.0和GDB 7.9.1).程序编译正常,但GDB仍然捕获未知信号和程序崩溃.

现在我实际上无法使用SDL2调试任何程序.所以,问题是,我能做些什么让它再次运作？

可能的解决方案:

• 使用Visual Studio - 我喜欢Eclipse(这意味着我开始容忍我不喜欢的东西)并且不想学习全新的IDE,但我会将其作为最后一个选项.
• 编译GDB - 尝试过,没有用,在Windows上编译的东西几乎从不适合我,而且GDB 7.12也有这个bug.
• 切换到Linux - 比转移到Visual Studio更加激进的选择.
• 回归到SDL 1.2 - 事情变得更容易了......
• 切换到任何其他库 - ...并希望他们将与GDB合作.这听起来并不像解决方案.
• 切换到不同的编译器？
• 禁用线程命名？

代码示例:

#include <SDL2/SDL.h>

// Normally I'd use #undef main
int WinMain(int, char**)
    {
    SDL_Init(SDL_INIT_EVERYTHING);

    return 0;
    }

编译:g ++ gdbtest.cpp -lSDL2main -lSDL2

SDL2版本:2.0.5(适用于Windows的最新版本,MinGW,32位版本)

正常运行:a.exe

结果:程序正常启动和结束

使用GDB运行:控制台日志

结果:GDB收到未知信号,程序崩溃

我创建了一个程序,它分配了两个C++双精度数组.首先包含从0到pi/4的x的sin(x)值.对于第二个,我写了sin(x)的二阶导数,使用三点公式计算:

(vals[i-1]-2*vals[i]+vals[i+1])/(dx*dx)

我对不同大小的数组执行这些计算,重复几次,并输出平均计算时间.这样我得到了很好的图表,显示了计算特定大小数组的衍生物所需的时间.

这一切听起来都相当容易,但我遇到了一个奇怪的问题.看一下图表: 当数组很小时,没有什么奇怪的事情发生.但是,当它们大于10000个元素(有两个数组意味着大约16kB 160kB的内存)时,我得到了周期性的峰值,每个峰值大约在前面的512个元素之后.这种情况发生在多个CPU(AMD Sempron 3850,Intel Q9400和Intel Xeon 5310)上,并不会发生在其他CPU(Intel i5 5200U,Intel Nehalem-C)上.

如果这还不够,当阵列达到约65,000个元素时,Windows 7上的AMD 3850会突然增加.这不会发生在Debian上.

我认为它可能与CPU缓存,给定'神奇'数量的元素以及操作系统的调度有关,但我想不出任何具体的解释和方法来确认它(除了分析CPU缓存命中率) .

码:

int main(int, char**)
    {   
    double maxerr=0.0;
    double avgerr=0.0;

    for(unsigned SIZE=5000u; SIZE<100000u; SIZE+=1u)
        {
        const unsigned REPEATS=10000000/SIZE+1;
        const double STEP=1.0/(SIZE-1.0)*atan(1.0)*4.0;

        double *vals;
        double *derivs;

        // Alokacja
        vals=  new double[SIZE];
        derivs=new double[SIZE];

        // Inicjalizacja
        for(unsigned i=0u; i<SIZE; ++i)
            {
            vals[i]=sin(i*STEP);
            derivs[i]=0.0;
            }

        // Obliczenia normalne
        const double TIME_FPU_START=msclock();

        for(unsigned r=0u; r<REPEATS; ++r)
            {
            const double STEP2RCP=1.0/(STEP*STEP);

            for(unsigned i=1u; i<SIZE-1u; ++i)
                { …

我们从代码开始吧.我有两个结构,一个用于矢量,另一个用于矩阵.

struct AVector
    {
    explicit AVector(float x=0.0f, float y=0.0f, float z=0.0f, float w=0.0f):
        x(x), y(y), z(z), w(w) {}
    AVector(const AVector& a):
        x(a.x), y(a.y), z(a.z), w(a.w) {}

    AVector& operator=(const AVector& a) {x=a.x; y=a.y; z=a.z; w=a.w; return *this;}

    float x, y, z, w;
    };

struct AMatrix
    {
    // Row-major
    explicit AMatrix(const AVector& a=AVector(), const AVector& b=AVector(), const AVector& c=AVector(), const AVector& d=AVector())
        {row[0]=a; row[1]=b; row[2]=c; row[3]=d;}
    AMatrix(const AMatrix& m) {row[0]=m.row[0]; row[1]=m.row[1]; row[2]=m.row[2]; row[3]=m.row[3];}

    AMatrix& operator=(const AMatrix& m) {row[0]=m.row[0]; row[1]=m.row[1]; row[2]=m.row[2]; row[3]=m.row[3]; return …