1

在我的大学练习中，我遇到了一个变量的奇怪行为。

/* Main parameters                                                          */
double sizeX, sizeY;      /* Size of the global domain                      */
int nPartX, nPartY;       /* Particle number in x, y direction              */
int nPart;                /* Total number of particles                      */
int nCellX, nCellY;       /* (Global) number of cells in x, y direction     */
int steps;                /* Number of timesteps                            */
double dt;                /* Stepsize for timesteps                         */
int logs;                 /* Whether or not we want to keep logfiles        */

void ReadInput(const char *fname)
{
  FILE *fp;
  char c;

  Debug("ReadInput", 0);
  if(rank == 0)
  {
    fp = fopen(fname, "r");
    if(!fp) Debug("Cannot open input file", 1);
    if(fscanf(fp, "sizeX: %lf\n", &sizeX) != 1) Debug("sizeX?",  1);
    if(fscanf(fp, "sizeY: %lf\n", &sizeY) != 1) Debug("sizeY?",  1);
    if(fscanf(fp, "nPartX:%i\n", &nPartX) != 1) Debug("nPartX?", 1);
    if(fscanf(fp, "nPartY:%i\n", &nPartY) != 1) Debug("nPartY?", 1);
    if(fscanf(fp, "nCellX:%i\n", &nCellX) != 1) Debug("nCellX?", 1); //read value is 10
    if(fscanf(fp, "nCellY:%i\n", &nCellY) != 1) Debug("nCellY?", 1);    
    if(fscanf(fp, "steps: %li\n", &steps) != 1) Debug("steps?",  1);    
//here the nCellX variable value 10 is changed somehow to 0
    if(fscanf(fp, "dt:    %lf\n", &dt)    != 1) Debug("dt?",     1);
    if(fscanf(fp, "logs:  %c\n",  &c)     != 1) Debug("logs?",   1);
    logs = (c == 'y');
    fclose(fp);
  }

  printf("(%i) reporting in...\n", rank);

  MPI_Bcast(&sizeX, 1, MPI_DOUBLE, 0, grid_comm);  
  MPI_Bcast(&sizeY, 1, MPI_DOUBLE, 0, grid_comm);
  MPI_Bcast(&nPartX,1, MPI_INT,    0, grid_comm);  
  MPI_Bcast(&nPartY,1, MPI_INT,    0, grid_comm);
  MPI_Bcast(&nCellX,1, MPI_INT,    0, grid_comm);
  MPI_Bcast(&nCellY,1, MPI_INT,    0, grid_comm);
  MPI_Bcast(&steps, 1, MPI_INT,    0, grid_comm);
  MPI_Bcast(&dt,    1, MPI_DOUBLE, 0, grid_comm);
  MPI_Bcast(&logs,  1, MPI_INT,    0, grid_comm);
  nPart = nPartX * nPartY;
  dt2 = dt * dt;
}

老师和我得出的结论是，如果我们将变量名从“nCellX”更改为“nCellX_2”，问题就消失了，代码按预期工作。另一个有趣的事情是，只有这个单一的全局变量有这个问题，其他变量都可以正常工作。我想知道是否有人也遇到过这种类型的问题。任何指导/解释将不胜感激。

如果这个问题不够清楚，请告诉我，如果需要完整的代码，我也可以提供。通常，代码是 Particle-in-Cell 的并行算法。

4

2 回答 2

5

以下代码行可能会导致问题：

if(fscanf(fp, "steps: %li\n", &steps) != 1) Debug("steps?",  1);

表示一个长整数，%li可能是 64 位，而steps是一个int，可能是 32 位。格式说明符应该%i代替%li.

是否存在实际问题取决于环境（例如，如果构建 64 位应用程序，这很可能是一个问题）。如果存在 64 位与 32 位不匹配，则fscanf调用将覆盖内存并可能破坏steps内存布局中跟随的任何变量（可能是nCellX）。请注意，使用-Wall选项应该警告您这种情况。为什么将 nCellX 的名称更改为不同的名称应该掩盖问题尚不清楚，但似乎更改名称可能会导致内存中变量的布局发生变化；我怀疑 C 标准不允许这样做（尽管我没有看过）。

于 2012-03-23T13:46:55.883 回答
2

作为对@Mark Wilkins & Co. 评论的确认，我试图证明明确命名可以产生影响。

在案例中：
fprintf()获取一个指针来存储它读取的内容。它不知道它指向的类型，而是从格式中获取定义并转换参数。像sscanf("36", "%i", &my_dest);-> number = va_arg(vl, int*);

为你的编译器使用正确的标志来捕捉这个

当 exec 启动一个程序时，它通常为称为 BSS 的区域中的未初始化数据（即 int foo;）分配地址。（请参见下面的图 1 中的图）。

在许多系统上，这将来自低内存地址及以上。

为了演示（在给定系统上）会发生什么，我们如下：

我从以下内容开始：

/* global scope */
unsigned char unA;
unsigned char unB;
unsigned char unC;
unsigned int  unD;

清单 1

在main()我说：

unA = '1';
unB = '2';
unC = '3';
/* bit shifting the "string" NAC! into unD, reverse order as my system is LSB 
 * first (little-endian), unD becomes 558055758 => by byte ASCII !CNA */
unD = 0 | ('!' << 24) | ('C' << 16) | ('A' << 8) | 'N';

清单 2

并将一个无符号字符指针指向unA并转储以下 16 个字节，结果是：
转储格式为 [char<dot>]，或带有前导零的十六进制（%c. 或 %02x）*

 +-- Address of unA
 |
0x804b06c: 1.3.0000N.A.C.!. 2.00000000000000 
           | |     |_____|  |
           | |        |     +--- unB
           | |        +--------- unD
           | +------------------ unC
           +-------------------- unA

清单 3

然后我将名称更改为unB，un2文件中的顺序相同：

unsigned char unA;
unsigned char un2;
unsigned char unC;
unsigned int  unD;

清单 4

现在我的转储给出：

 +-- Address of unA
 |
0x804b06c: 1.3.2.00N.A.C.!. 0000000000000000
           | | |   |_____|  
           | | |      +--------- unD
           | | +---------------- unB
           | +------------------ unC
           +-------------------- unA

清单 5

可以看到地址/对齐的顺序已经改变。类型没有变化，只是名称上的变化。

分配错误的类型：

下一步是转换和溢出类型的范围。改un2回unB. 我们有清单 3中的对齐方式。

我们创建一个函数来设置字节（在具有 4 字节/32 位 int 的系统上），高位为：

void set_what(unsigned int *n)
{
    *n = 0 | ('t' << 24) | ('a' << 16) | ('h' << 8) | 'w';
    /* or *n = 0x74616877; in an ASCII environment 
     * 0x74 0x61 0x68 0x77 == tahw */
}

清单 6

在main()我们说：

/* dump */
set_what((unsigned int*)&unA);
/* dump */

清单 7

并得到：

0x804b06c: 1.3.0000N.A.C.!. 2.00000000000000
0x804b06c: w.h.a.t.N.A.C.!. 2.00000000000000

清单 8

或者：

set_what((unsigned int*)&unB); -> Yield:
0x804b06c: 1.3.0000N.A.C.!. 2.00000000000000
0x804b06c: 1.3.0000N.A.C.!. w.h.a.t.00000000

set_what((unsigned int*)&unC); -> Yield:
0x804b06c: 1.3.0000N.A.C.!. 2.00000000000000
0x804b06c: 1.w.h.a.t.A.C.!. 2.00000000000000

清单 9

正如人们所看到的，无论类型如何，数据都被覆盖了。

在某些情况下，这将导致 SIGSEGV。

对于您的代码中的问题，如前面的评论所述，但我重复一遍。

在您所说的声明int steps中并在fscanf()您指定%li 哪个是 along int而不是 a int。在少数系统上，这可能影响不大，但在 64 位系统上，一切都会变糟。

通过 asm 检查：

我们复制代码并制作两份副本，一份long int steps;带有 int steps;名为A :lin_ok.c和B :的副本lin_bad.c。然后我们创建一些 asm 输出。

A $ cpp lin_ok.c > lin_ok_m32.i
A $ cpp lin_ok.c > lin_ok_m64.i
B $ cpp lin_bad.c > lin_bad_m32.i
B $ cpp lin_bad.c > lin_bad_m64.i

A $ gcc -std=c89 -m32 -S lin_ok_m32.i
A $ gcc -std=c89 -m64 -S lin_ok_m64.i
B $ gcc -std=c89 -m32 -S lin_bad_m32.i
B $ gcc -std=c89 -m64 -S lin_bad_m64.i


$ diff lin_ok_m32.s lin_ok_m64.s | head
9c9
<   .comm   steps,4,4   ; reserve 4 bytes
---
>   .comm   steps,8,8   ; reserve 8 bytes
...

可以看到代码指示在 64 位上保留 8 个字节，在 32 位（本系统）上保留 4 个字节steps。

如果您使用 gcc，请使用更多标志进行编译。我个人通常使用：

gcc -Wall- Wextra -pedantic -std=c89 -o main main.c 或者-std=c99如果需要。

这将为您提供有关 scanf 类型错误等问题的警告。

正在运行的应用程序的布局示例。它可以完全不同，具体取决于系统等，但它是一个 aprox AFAIK。希望我大部分都做对了。

 ________________                       _________________
[                ]                     [                 ]
[                ]                     [ Physical memory ]
[ Virtual memory ] <-- Translation --> [                 ]
[     range      ]        table        { - - - - - - - - }
[________________]                     [                 ]
    |                                  [_________________]
    |
 +--+ high address : Virtual address
 |
0xF00 +-------------------+'''''''''''''''''' Runnning env
      | argv, env-vars, ..|                              |
0xBFF +-------------------+                              | ptr
      |       stack       | <- Running storage, where    |
      |...  grows down ...|  fun_a should return, local  | 0xC0000000 on
      |                   |  variables, env, ...         | linux Intel x86
      |  < huge area  >   |  New frame allocated for     |
      |                   |  recursive calls etc.        |
      |...   grows up  ...|                              |     
      |                   | <- Dynamic memory alloc.     |
      |       heap        |  malloc, etc                 |
0x9e49+-------------------+                              | 
      | double sizeX;     | <- Uninitialized data        |
bss   | ...               |           BSS 000000 ...     |
seg.  | int nCellY        |                              |
      | int steps;        |                              |
0x804c+-------------------+''''''''''''''''''''' Stored '| --- edata
data  |                   |                        on    |
seg.  | int rank = 0;     | <- Initialized data   disk   |
0x804b+-------------------+                         :    | --- etext
      | main()            |                         :    |
text  | mov ecx, edx      | <- Instructions         :    | 0x08048000 on
seg.  | ELF, or the like  |   Layout, link, etc     :    | linux Intel x86
0x8040+-------------------+ ''''''''''''''''''''''''''''''
 |
 +--- low address : Virtual address

图。1。

于 2012-03-25T10:18:11.250 回答