1

好的。我原来的问题原来是由于没有初始化一些数组引起的。最初的问题与代码崩溃 R 有关。当我试图通过注释掉它来调试它时，我错误地注释掉了初始化数组的行。所以我认为我的问题与传递指针有关。

实际问题是这样的。正如我之前所说，我想用来outer_pos计算外部差异并将结果的指针和正差异的总数传回调用的函数outer_pos

#include <R.h>
#include <Rmath.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>


void outer_pos(double *x, double *y, int *n, double *output){
    int i, j, l=0;
    for(i=0; i<*n; i++){
        for(j=0; j<*n; j++){
            if((x[j]-x[i])>0){
                output[l+1]=(y[j]-y[i])/(x[j]-x[i]);
                output[0]=(double)(++l);
            }
        }
    } 
    Rprintf("%d\n", (int)output[0]);
}


void foo1(double *x, double *y, int *nsamp){
    int i, j, k, oper=2, l;
    double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));

    outer_pos(x, y, nsamp, &v1v2[0]);
    double v1v2b[1999000];    // <--------------HERE
    for(i=1; i<= (int)v1v2[0]; i++){
        v1v2b[i-1]=1;
    }
}

假设foo1是调用outer_pos. 在这里，我使用实际数字 1999000 指定了数组的大小。v1v2b该值对应于正差的数量。foo1从 R调用没有问题。一切都好。

在上面的场景中，我知道正差的数量，所以我可以使用实际值来设置数组大小。但我想适应我不一定知道价值的情况。foo2下面旨在做到这一点。如您所见，v1v2b使用数组的第一个值进行初始化v1v2。回想一下，输出的第一个槽outer_pos存储了正差的数量。所以基本上我使用这个值来设置v1v2的大小。但是，在 R 中调用此函数会导致 R 显示堆栈溢出错误或导致其崩溃（请参见下面的屏幕截图）

void foo2(double *x, double *y, int *nsamp){
    int i, j, k, oper=2, l;
    double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));

    outer_pos(x, y, nsamp, &v1v2[0]);
    double v1v2b[(int)v1v2[0]];        //<--------HERE
    for(i=1; i<= (int)v1v2[0]; i++){
        v1v2b[i-1]=1;
    }
}

所以我想，也许它与索引有关。也许 v1v2b 的实际大小太小，或者其他什么，所以循环在边界之外迭代。所以我创建foo2b了其中我注释掉循环，并使用Rprintf打印第一个槽v1v2来查看存储在其中的值是否正确。但似乎该值v1v2[0]是正确的，即1999000。所以我不知道这里发生了什么。

抱歉让我之前的问题感到困惑！！

void foo2b(double *x, double *y, int *nsamp){
        int i, j, k, oper=2, l;
        double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));

        outer_pos(x, y, nsamp, &v1v2[0]);
        double v1v2b[(int)v1v2[0]];         //<----Array size declared by a variable
       Rprintf("%d", (int)v1v2[0]);
        //for(i=1; i<= (int)v1v2[0]; i++){
            //v1v2b[i-1]=v1v2[i];
        //}
}

运行上述代码的 R 代码：

x=rnorm(2000)
y=rnorm(2000)
.C("foo1", x=as.double(x), y=as.double(y), nsamp=as.integer(2000))
.C("foo2", x=as.double(x), y=as.double(y), nsamp=as.integer(2000))
.C("foo2b", x=as.double(x), y=as.double(y), nsamp=as.integer(2000))

在此处输入图像描述 在此处输入图像描述

** 跟进 **

我根据 Martin 的建议修改了我的代码，以检查是否可以解决堆栈溢出问题：

void foo2b(double *x, double *y, int *nsamp) {
    int n = *nsamp, i;
    double *v1v2, *v1v2b;

    v1v2 = (double *) R_alloc(n * (n - 1) / 2 + 1, sizeof(double));
    /* outer_pos(x, y, nsamp, v1v2); */
    v1v2b = (double *) R_alloc((size_t) v1v2[0], sizeof(int));
    for(i=0; i< (int)v1v2[0]; i++){
        v1v2b[i]=1;
    }
    //qsort(v1v2b, (size_t) v1v2[0], sizeof(double), mycompare);
    /* ... */
}

编译后，我运行代码：

x=rnorm(1000)
y=rnorm(1000)
.C("foo2b", x=as.double(x), y=as.double(y), nsamp=as.integer(length(x)))

并收到一条错误消息：错误：无法分配大小为 34359738368.0 Gb 的内存块

** 跟进 2 **

似乎该错误消息显示了该函数的所有其他运行。至少它没有崩溃 R...所以基本上功能在正常运行和显示错误消息之间交替。（我在脚本文件中包含了两个标题）。

4

2 回答 2

2

和以前一样，您在堆栈上分配，但应该从堆中分配。使用 malloc / free 更正此问题，就像您在上一个问题中所做的那样（实际上，我认为推荐的方法是 Calloc / Free 或者如果您的代码返回到 R 只是 R_alloc；R_alloc 在返回到 R 时自动恢复内存，即使在R 捕获的错误）。

qsort在评论中提到。它将用户提供的函数作为其最后一个参数，该函数定义了如何对第一个参数进行排序。qsort (from man qsort) 的签名是

void qsort(void *base, size_t nmemb, size_t size,
           int(*compar)(const void *, const void *));

最后一个参数是“指向一个函数的指针，该函数接受两个常量 void 指针并返回一个 int”。满足此签名并根据手册页上的规范对指向两个双精度的指针进行排序的函数是

int mycompare(const void *p1, const void *p2)
{
    const double d1 = *(const double *) p1,
                 d2 = *(const double *) p2;
    return d1 < d2 ? -1 : (d2 > d1 ? 1 : 0);
}

所以

#include <Rdefines.h>
#include <stdlib.h>

int mycompare(const void *p1, const void *p2)
{
    const double d1 = *(const double *) p1,
                 d2 = *(const double *) p2;
    return d1 < d2 ? -1 : (d2 > d1 ? 1 : 0);
}

void outer_pos(double *x, double *y, int *n, double *output){
    int i, j, l = 0;
    for (i = 0; i < *n; i++) {
        for (j = 0; j < *n; j++) {
            if ((x[j] - x[i]) > 0) {
                output[l + 1] = (y[j] - y[i]) / (x[j] - x[i]);
                output[0] = (double)(++l);
            }
        }
    } 
}

void foo2b(double *x, double *y, int *nsamp) {
    int n = *nsamp;
    double *v1v2, *v1v2b;

    v1v2 = (double *) R_alloc(n * (n - 1) / 2 + 1, sizeof(double));
    outer_pos(x, y, nsamp, v1v2);
    v1v2b = (double *) R_alloc((size_t) v1v2[0], sizeof(double));
    qsort(v1v2b, (size_t) v1v2[0], sizeof(double), mycompare);
    /* ... */
}
于 2013-05-11T00:55:35.280 回答
2

foo2b调用时，它将两个已分配但未初始化的数组作为和outer_pos传递。您不能依赖它们的内容，因此您会从不同的调用中得到不同的结果。xy

编辑

1999000 doubles 的堆栈大小非常接近您的堆栈大小，这需要超过 15.25MB，这是因为您使用的是 Mac OS。在大多数其他平台上，线程不会接近 16M 的堆栈。

当你调用这个函数时，你不会从一个干净的（空的）堆栈开始——你深入到了 R 函数中，每个函数都创建了占用堆栈空间的帧。

编辑 2

下面，您使用未初始化的值v1v2[0]作为R-alloc. 有时（并非总是）您会遇到错误并不奇怪。

v1v2 = (double *) R_alloc(n * (n - 1) / 2 + 1, sizeof(double));
/* outer_pos(x, y, nsamp, v1v2); */
v1v2b = (double *) R_alloc((size_t) v1v2[0], sizeof(int));
于 2013-05-10T20:40:15.680 回答