आर कोड द्वारा बुलाया गया कोड

Question

क्रैश करता रहता है नीचे लिखा गया सी कोड का हिस्सा है। फंक्शन foo को आर में बुलाया जाना है। कोड आर को क्रैश करने के कारण रहता है, और मैंने समस्या को outer() फ़ंक्शन पर संकुचित कर दिया है, जिसका उपयोग बाहरी योग या अंतर की गणना करने के लिए किया जाता है। टिप्पणी की गई टिप्पणी पर ध्यान दें: यदि मैं इसे टिप्पणी नहीं करता हूं, तो फ़ंक्शन को क्रैश करने के लिए आर का नेतृत्व करेगा यदि प्रत्येक सरणी में 1000 डेटा पॉइंट शामिल हैं। अगर मैं इसे टिप्पणी करता हूं, तो मैं बिना किसी समस्या के काफी लंबे समय तक सरणी के लिए बाहरी योग/अंतर की गणना कर सकता हूं (उदाहरण के लिए, प्रति सरणी 100000 से अधिक डेटा पॉइंट)। मुझे आश्चर्य है कि समस्या क्या है ... धन्यवाद!

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

void outer(double *x1, double *x2, int *n, int operation, double *output){ 
int i, j; 
if(operation==1){ 
    for(i=0; i<*n; i++){ 
     for(j=0; j<*n; j++){ 
      output[(*n)*i+j]=x1[j]+x2[i]; 
     } 
    } 
} else if(operation==2){ 
    for(i=0; i<*n; i++){ 
     for(j=0; j<*n; j++){ 
      output[(*n)*i+j]=x1[j]-x2[i]; 
      //Rprintf("%d ", (*n)*i+j); //<-----------HERE 
     } 
    } 
} 
} 


void foo(double *x, double *y, int *npred, int *nsamp){ 
int oper=2; 
double xouter[*nsamp], youter[*nsamp]; 
double outer_temp_x[(*nsamp)*(*nsamp)], outer_temp_y[(*nsamp)*(*nsamp)]; 

outer(x, x, nsamp, oper, &outer_temp_x[0]); 
outer(y, y, nsamp, oper, &outer_temp_y[0]); 

} 

// कोड संकलन के बाद, मैं नीचे दिए गए कोड आर में उपयोग समारोह कॉल करने के लिए:

dyn.load("foo.so") 
x=as.matrix(rnorm(10000)) 
y=rlnorm(10000) 

invisible(.C("foo", 
      x=as.double(as.vector(x)), 
      y=as.double(y), 
      npred=as.integer(ncol(x)), 
      nsamp=as.integer(length(y)) 
     ) 

Answer 1

मुझे लगता है कि यह ढेर overunning और मुसीबत खड़ी कर रहा है।

इस प्रयास करें:

void foo(double *x, double *y, int *npred, int *nsamp){ 
    int oper=2; 
    double xouter[*nsamp], youter[*nsamp]; 

    // The prior code allocated on the stack. Here, we make a pair of calls 
    // to 'malloc' to allocate memory for the arrays. This gets memory from 
    // the heap. The stack is fairly limited, but the heap is huge. 
    // 'malloc' returns a pointer to the allocated memory. 

    double* outer_temp_x=malloc(sizeof(double)*(*nsamp)*(*nsamp)); 
    double* outer_temp_y=malloc(sizeof(double)*(*nsamp)*(*nsamp)); 

    outer(x, x, nsamp, oper, &outer_temp_x[0]); 
    outer(y, y, nsamp, oper, &outer_temp_y[0]); 

    // The downside of allocating on the heap, is that you must release the 
    // memory at some point. Otherwise you have what's called a "memory leak." 
    // 'free' is the function to free the memory, and it is called on the 
    // pointer value returned by 'malloc'. 

    free(outer_temp_x); 
    free(outer_temp_y); 
}