c言語のメモリの動的確保について

Question

実現したいこと

c言語のmallocによるメモリの動的確保について、気になることがあり質問させていただきます。
質問としては、mallocを使いすぎることでメモリを確保する際にmalloc同士で干渉などを起こすことがあるのでしょうか？
といのも、以下のコードでは配列を返す自作関数内でmallocを用いてメモリを動的に確保しており、main関数内ではその自作関数を計11回呼び出しています。このプログラムを実行するとコンパイルはできるのですが、実行すると何度やってもセグメンテーションエラーになり、実行できませんでした。しかし、mallocを使っている関数を一部コメントアウトし、main関数内でもコメントアウトした関数の呼び出し部をコメントアウトして実行すると、エラーにならず実行できました。その後、コメントアウトを解除して実行すると今度はセグメンテーションエラーにならずに実行できました。
このようなことがおきた原因として、malloc同士での干渉があったのかなとも思ったのですが、調べてもあまりピンとくるものがありませんでした。以前にもmallocを大量に使ったプログラム（20個ほどだった気がします。）を書いたのですが、その時は何も問題なく実行できたので、なおさら不思議です。これに関して意見を頂戴したく、質問させていただきました。どなたかわかる方、ご教授のほどよろしくお願いいたします。

該当のソースコード

#include	<stdio.h>
#include	<stdlib.h>
#include	<math.h>
#include     <string.h>

#define N 1024

int  fft1();
int  window_func();

void swap(float *x, float *y);

double* freq(void);
double* CalcPower(double data[]);
double* Kurtosis(double a[], double b[], double c[], double d[]);


int main(int argc,const char *argv[])
{
  int	i, j, k, n, n_frame, iter, flag;
  int  n_frame = 2929;

  char    datar[256], datai[256];
  
  float   ar1[N], ai1[N], ar2[N], ai2[N];
    
  double  pwr1, pwi1, pwr2, pwi2;
  
  double  dcnt;
  
  double  S1r1[N], S2r1[N], S3r1[N], S4r1[N], S6r1[N];
  double  S1i1[N], S2i1[N], S3i1[N], S4i1[N];
  double  Myu1r1[N], Myu2r1[N], Myu3r1[N], Myu4r1[N];
  double  Myu1i1[N], Myu2i1[N], Myu3i1[N], Myu4i1[N];
  
  double  S1r2[N], S2r2[N], S3r2[N], S4r2[N], S6r2[N];
  double  S1i2[N], S2i2[N], S3i2[N], S4i2[N];
  double  Myu1r2[N], Myu2r2[N], Myu3r2[N], Myu4r2[N];
  double  Myu1i2[N], Myu2i2[N], Myu3i2[N], Myu4i2[N];
  
  double  sub_Myu1r[N], sub_Myu2r[N], sub_Myu3r[N], sub_Myu4r[N];
  double  sub_Myu1i[N], sub_Myu2i[N], sub_Myu3i[N], sub_Myu4i[N];
  
  double  Myu21[N], Myu22[N], sub_Myu2[N];
  double  sub_myu2[N], b[N], h[N], h1[N];	
  double  d[N], d1[N];
  double  sub_d[N];
  
  double  sub_d_neighbor[N], sub_d_neighbor1[N];
  double  v[N], v1[N], sub_v[N], sub_v1[N];
  
  double  modi_Myu2_freq[N];
  
  double* fq = NULL;

  double* Kr = NULL;
  double* Ki = NULL;
  double* Ka = NULL;
  double* Kb = NULL;
  
  double  Mr[N], Mi[N], Ma[N], Mb[N];
  double  Fr[N], Fi[N];
  double  br[N], bi[N], ba[N], bb[N], qr[N], qa[N];
  double  xr[N], xi[N], xa[N], xb[N], qi[N], qb[N];
  
  double  modi_Myu2_kur1[N]; 
  double  modi_Myu2_kur2[N]; 
  
  double  com[N];
  double  modi_Myu2_com[N]; 

  double* Myu21_power = NULL;
  double* sub_Myu2_power = NULL;
  double* modi_power_com = NULL;  
  double* modi_power_kur1 = NULL;
  double* modi_power_kur2 = NULL;
  double* modi_power_freq = NULL;
  	
  FILE  *fp, *fp1;
  
  for(i = 0; i < N; i++)
  {
    ar1[i] = 0.0;
    ai1[i] = 0.0;
    ar2[i] = 0.0;
    ai2[i] = 0.0;
    
    Myu21[i] = 0.0;
    Myu22[i] = 0.0;
     
    S1r1[i] = 0.0;
    S1i1[i] = 0.0;
    S2r1[i] = 0.0;
    S2i1[i] = 0.0;
    S3r1[i] = 0.0;
    S3i1[i] = 0.0;
    S4r1[i] = 0.0;
    S4i1[i] = 0.0;
    
    S1r2[i] = 0.0;
    S1i2[i] = 0.0;
    S2r2[i] = 0.0;
    S2i2[i] = 0.0;
    S3r2[i] = 0.0;
    S3i2[i] = 0.0;
    S4r2[i] = 0.0;
    S4i2[i] = 0.0;
    
    Myu1r1[i] = 0.0;
    Myu1i1[i] = 0.0;
    Myu2r1[i] = 0.0;
    Myu2i1[i] = 0.0;
    Myu3r1[i] = 0.0;
    Myu3i1[i] = 0.0;
    Myu4r1[i] = 0.0;
    Myu4i1[i] = 0.0;
  }
  
  pwr1 = 0.0;
  pwi1 = 0.0;
  pwr2 = 0.0;
  pwi2 = 0.0;

  dcnt = 0.0;

  fp  = fopen(argv[1],"r");
  fp1 = fopen(argv[2],"r");

  if(fp == NULL)
    printf("fp:cannnot open file\n");
  else
    printf("fp:open file\n");

  if(fp1 == NULL)
    printf("fp1:cannnot open file\n");
  else
    printf("fp1:open file\n");

  
  iter = 0;
  flag = 0;

  for(n = 0; n < n_frame; n++)
  {
    for(i = 0; i < N; i++)
    {
      fgets(datar, sizeof(datar), fp);
      ar1[i] = atof(datar);
      ar2[i] = 0.0;
    }
                  
    for(i = 0; i < N; i++)
    {
      fgets(datai, sizeof(datai), fp1);
      ar2[i] = atof(datai);
      ai2[i] = 0.0;
    }
    
    window_func(ar1, N);
    window_func(ai1, N);
    fft1(ar1, ai1, N, iter, flag);
    
    window_func(ar2, N);
    window_func(ai2, N);
    fft1(ar2, ai2, N, iter, flag);

    for(i = 0; i < N/2; i++)
    {
      swap(&ar1[i], &ar1[N/2+i]);
      swap(&ai1[i], &ai1[N/2+i]);
      swap(&ar2[i], &ar2[N/2+i]);
      swap(&ai2[i], &ai2[N/2+i]);
    }
    
    for(i = 0; i < N; i++)
    {
      pwr1      =  ar1[i];
      pwi1      =  ai1[i];
	    
      S1r1[i]  +=  (double)pwr1;
      S1i1[i]  +=  (double)pwi1;
	    
      S2r1[i]  +=  pow((double)pwr1, 2.0);
      S2i1[i]  +=  pow((double)pwi1, 2.0);
	    
      S3r1[i]  +=  pow((double)pwr1, 3.0);
      S3i1[i]  +=  pow((double)pwi1, 3.0);
	    
      S4r1[i]  +=  pow((double)pwr1, 4.0);
      S4i1[i]  +=  pow((double)pwi1, 4.0);
    }
        
    dcnt++;
    
  }

  printf("\n");
  fclose(fp);
  fclose(fp1);
   
  fq = freq();

  for(i = 0; i < N; i++)
  {
    Myu1r1[i] = S1r1[i] / dcnt;
    Myu1i1[i] = S1i1[i] / dcnt;
	  
    Myu2r1[i] = S2r1[i] / dcnt;
    Myu2i1[i] = S2i1[i] / dcnt;
	  
    Myu3r1[i] = S3r1[i] / dcnt;
    Myu3i1[i] = S3i1[i] / dcnt;
	  
    Myu4r1[i] = S4r1[i] / dcnt;
    Myu4i1[i] = S4i1[i] / dcnt;

    Myu21[i] = Myu2r1[i] + Myu2i1[i];
  }

  
Myu21_power = CalcPower(Myu21);
  sub_Myu2_power = CalcPower(Myu21);
  
  modi_power_freq = CalcPower(Myu21);

  Kr = Kurtosis(Myu1r1, Myu2r1, Myu3r1, Myu4r1);  
  Ki = Kurtosis(Myu1i1, Myu2i1, Myu3i1, Myu4i1);
  
  Ka = Kurtosis(Myu1r1, Myu2r1, Myu3r1, Myu4r1);  
  Kb = Kurtosis(Myu1i1, Myu2i1, Myu3i1,  Myu4i1);

  modi_power_kur1 = CalcPower(Myu21);
  modi_power_kur2 = CalcPower(Myu21);

  modi_power_com = CalcPower(Myu21);
  
  free(fq);
  free(Kr);
  free(Ki);
  free(Ka);
  free(Kb);
  free(Myu21_power);
  free(sub_Myu2_power);
  free(modi_power_com);
  free(modi_power_freq);
  free(modi_power_kur1);
  free(modi_power_kur2);
  
  return 0;
	
}

void swap(float *x, float *y)
{
  float temp;
  
  temp = *x;
  *x   = *y;
  *y   = temp;
}
	
int fft1(float ar[], float ai[], int n, int iter, int flag)
{
  int    i, j, it, xp, xp2, k, j1, j2, im1, jm1;
  double sign, w, wr, wi, dr1, dr2, di1, di2, tr, ti, arg;

  if(n < 2) return(999);

  if(iter <= 0)
  {
    iter = 0;
    i = n;
    
    while(1)
    {
      if((i /= 2) == 0) break;
      iter++;
    }
  }

  j = 1;
  
  for(i = 0; i < iter; i++) j *= 2;
  
  if(n != j) return(1);
  
  if(flag == 1) sign=1.0;
  else sign=-1.0;
  
  xp2 = n;

  for(it = 0; it < iter; it++)
  {
    xp = xp2;
    xp2 = xp / 2;
    w = 3.141592653589793 / xp2;
    
    for(k = 0; k < xp2; k++)
    {
      arg = k * w;
      wr = cos(arg);
      wi = sign * sin(arg);
      i = k - xp;
      
      for(j = xp; j <= n; j += xp)
      {
        j1  = j + i;
        j2  = j1 + xp2;
        dr1 = ar[j1];
        dr2 = ar[j2];
        di1 = ai[j1];
        di2 = ai[j2];
        tr  = dr1 - dr2;
        ti  = di1 - di2;
        
        ar[j1] = dr1 + dr2;
        ai[j1] = di1 + di2;
        ar[j2] = tr * wr - ti * wi;
        ai[j2] = ti * wr + tr * wi;	      
      }
    }
  }

  j1 = n / 2;
  j2 = n - 1;
  j = 1;

  for(i = 1; i <= j2; i++)
  {
    if(i < j)
    {
      im1 = i - 1;
      jm1 = j - 1;
      tr  = ar[jm1];
      ti  = ai[jm1];
      
      ar[jm1] = ar[im1];
      ai[jm1] = ai[im1];
      ar[im1] = tr;
      ai[im1] = ti;
    }
  
    k = j1;
  
    while(k < j)
    {
      j -= k;
      k /= 2;
    }
	  
    j += k;
  }

  if(flag == 0) return(0);
  
  w = n;

  for(i = 0; i < n; i++)
  {
    ar[i] = ar[i] / w;
    ai[i] = ai[i] / w;
  }
  
  return(0);
}


int window_func(float frame[], int n)
{
  int	 i;
  float  winv[n];
  double pi = 3.141592653589793;

  for(i = 0; i < n; i++)
  {
    winv[i] = 0.35875 - 0.48829 * cos(2.0*pi*i/(n-1)) + 0.14128 * cos(4.0*pi*i/(n-1)) - 0.01168 * cos(6.0*pi*i/(n-1));

    frame[i] = frame[i] * winv[i];
  }

  return(0);
}

double* CalcPower(double data[])
{
  int i;
  double av[N];
  double* power = (double*)malloc(N * sizeof(double));
  
  for(i = 0; i < N; i++)
    av[i] = 0.0;
  
  for(i = 0; i < N; i++)
  {
    av[i] = data[i] / 1000000;
    power[i] = 10 * log10(av[i]);
  }
  
  return power;
}

double* Kurtosis(double Myu1[], double Myu2[], double Myu3[], double Myu4[])
{
  int i;
  double M1[N], M2[N], M3[N], M4[N];
  double top[N], bottom[N];
  double* K = (double*)malloc(N * sizeof(double));
    
  for(i = 0; i < N; i++)
  {
    M1[i] = 0.0;
    M2[i] = 0.0;
    M3[i] = 0.0;
    M4[i] = 0.0;
      
    top[i] = 0.0;
    bottom[i] = 0.0;
  }
    
  for(i = 0; i < N; i++)
  {
    M1[i] = 4.0 * Myu3[i] * Myu1[i];

    M2[i] = 6.0 * Myu2[i] * Myu1[i] * Myu1[i];

    M3[i] = 3.0 * Myu1[i] * Myu1[i] * Myu1[i] * Myu1[i];

    M4[i] = Myu2[i] - (Myu1[i] * Myu1[i]);
  }
    
  for(i = 0; i < N; i++)
  {
    top[i] = Myu4[i] - M1[i] + M2[i] - M3[i];  
    bottom[i] = M4[i] * M4[i];
  }
    
  for(i = 0; i < N; i++)
  {
    K[i] = top[i] / bottom[i];  
  }
  
  return K;
  
}

double* freq(void)
{
  int i;
  double* fq = (double*)malloc(N * sizeof(double));
  
  for(i = 0; i < N; i++)
    fq[i] = (875.0 + 6000.0 + (30.0/1024.0) * i) / 1000.0;
  
  return fq;
  
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N  3000000

double GetRandom();

int main()
{
  int i;
  FILE *fp, *fp1;
  
  fp    = fopen("rand1.dat", "w");
  fp1 = fopen("rand2.dat", "w");
  
  srand((unsigned int)time(NULL));
  for(i = 0; i < N; i++)  
  {
    fprintf(fp, "%f\n", GetRandom(0,1));     
    fprintf(fp1, "%f\n", GetRandom(0,1));  
  }

  fclose(fp);
  fclose(fp1);
  
  return 0;
}

double GetRandom(int min, int max)
{
  return min + (double)(rand() * (max - min + 1.0) / (1.0 + RAND_MAX));
}  

補足情報（FW/ツールのバージョンなど）

No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 20.04.6 LTS
Release: 20.04
Codename: focal

Comments

[episteme]

「malloc同士での干渉」とは何ですか? 何が/どう干渉するんですか?

[maisumakun]

Nを変数でなく#defineで定義してみたらどうなりますでしょうか？

（変数で個数を決めてローカル配列を確保するのはVLAといって、これもまた別種の動的確保となります）

[tatsu99]

提示されたソースをコンパイルして、実行すると、どうなるのでしょうか。
又、どうなることを期待されているのでしょうか。

[int32_t]

malloc() の問題というより、ローカル変数多すぎでスタック枯渇かもしれませんね。

[Zuishin]

私もこの程度の malloc でメモリが枯渇するというのは考えにくいと思います。
ローカル変数ならあり得ますね。

しかし、関数呼び出しをコメントアウトして動いたというなら、コメントアウトしなかった場合にはスタックオーバーフローになりそうですが。

[jimbe]

プログラムに問題が一切無いのに malloc で干渉とやらが発生するのなら、 OS がおかしいということになるでしょう。
推測では無く仮説を立ててそれを確認していく作業が必要です。

[Zuishin]

謎なのは、メモリを確保しているのに main で使っていないところです。
処理が省略されているのであれば、そこに問題がある可能性があります。
もしこのコードが問題の起きるコードでないのであれば、こちらでは推測しかできず、質問者側で検証しなければいけません。
もっとも、私はコンパイルも実行もせず斜め読みしただけなので、このコードに問題があるのかどうかすら知りませんが。

[yu_89]

ご回答いただき、ありがとうございます。
episteme様
double* Kurtosis()だけ残してあとの関数をコメントアウトすると実行できて、その後、関数のコメントアウトを全て外して実行すると今度はセグメンテーションフォルトにならずに実行できたので、干渉するというか、mallocを使いすぎるが故にメモリの確保時にバグってエラーになったのかな、そういうこともあるのかなと思いまして。

[yu_89]

ご回答いただき、ありがとうございます。
maisumakun様
#defineで定義しても実行することができました。

[yu_89]

ご回答いただき、ありがとうございます。
int32_t様、Zuishin様
なるほど。やっぱり、ローカル変数は多すぎですかね。コードはだいぶ省略していますが、実際には1000行以上あって極力変数を少なくして書いているつもりなのですが、もう少し、減らせるように工夫してみます。

[yu_89]

ご回答いただき、ありがとうございます。
jimbe様
確かにそうですね。今の段階では憶測に過ぎないので、仮設を立てて検証してみようと思います。

[yu_89]

ご回答いただき、ありがとうございます。
tatsu99様
コードは質問に必要だと思う部分だけを抜き出して載せています。
どうなることを期待するというより、mallocの使いすぎでエラーになることがあるのかどうかとういことが知りたかったので質問させていただきました。

[Zuishin]

変数の数というより、配列がスタックに確保されているんじゃないですか？

[Zuishin]

> コードは質問に必要だと思う部分だけを抜き出して載せています。

「思う」ではなく、ログをとってどこでエラーになっているか調べるのが良いと思います。

[melian]

スタックの使用量に関して言えば、大体 690 kb 程度です。

$ lsb_release -rc
Release: 22.04
Codename: jammy

$ gcc --version
gcc (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0

$ gcc -std=gnu2x -Wall -Wextra -g -o calc calc.c -lm
$ gdb ./calc
(gdb) break 88
Breakpoint 1 at 0x58a3: file calc.c, line 88.
(gdb) run
Starting program: calc
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, main (argc=1, argv=0x7fffffffe118) at calc.c:88
88 modi_power_freq = CalcPower(sub_Myu2, N);
(gdb) p (char *)_environ - (char *)$sp
$1 = 709144

heap の使用量(free() の直前)は以下の通り。

(gdb) break 106
(gdb) run
(gdb) call malloc_stats()
Arena 0:
system bytes = 135168
in use bytes = 83776
Total (incl. mmap):
system bytes = 135168
in use bytes = 83776
max mmap regions = 0
max mmap bytes = 0

[yu_89]

Zuishin様
確かに、スタックオーバーフロウの可能性もありますね。
なるほど。ログをとってエラーを調べるという方法もあるのですね。調べてやってみます。
ご助言、ありがとうございます。

[yu_89]

ご回答いただき、ありがとうございます。
melian様
gdbで使用量が調べられるのですね。知りませんでした。ありがとうございます。試してみます。

[Zuishin]

ローカル変数が原因の可能性もあるけど、それだとスタックオーバーフローが出るはずなので、ここに書いていない部分に問題があるんじゃないかと書きました。

[melian]

Ubuntu ですと、スタックサイズのデフォルトは 8 MB です。

$ ulimit -s
8192

例えば、スタックサイズを 600 kb にして、件のプログラムを実行すると segmentation fault が発生します。

$ ulimit -s 600
$ ulimit -s
600
$ ./calc
Segmentation fault (core dumped)

[Zuishin]

そんなピンポイントなサイズなんですかね。
コメントアウトすれば動くと書いていますが。

[yu_89]

Zuishin様
なるほど、そうだったんですね。ありがとうございます。
melian様が教えてくださった方法やZuishin様が教えてくださったログを取るなどしてエラーのでる原因を調べてみます。

[yu_89]

melian様
確かにスタックサイズをおとして実行すると再びセグメンテーションフォルトになりました。
変数によるスタック枯渇の可能性も大きいかなと思います。

[thkana]

「このプログラムを実行すると何度やっても」私のてもとではエラー出ないのですけど...そのサンプルでSegmentation faultが出ているのですよね? 「実際には1000行以上」あるというのではなく。
(いやまぁ、C/C++ではエラーが表面化するかしないかは運次第、なんてのは普通ですけれど)

> double* Kurtosis()だけ残してあとの関数をコメントアウトすると実行できて、その後、関数のコメントアウトを全て外して実行すると今度はセグメンテーションフォルトにならずに実行できた
どちらも実行できた、と書いてありますが正しいですか?

> mallocの使いすぎでエラーになることがあるのかどうか
コンパイラも人間が作ったものですから...というレベルで言うなら絶対大丈夫とは言えませんが、
gccを一体どれだけの人が使っているかを考えると、この程度のプログラムで誤動作が起こるというのは宝くじの特等を連続で引くよりレアなことと思います。そういうレベルで「そんなことはない」と言っていいのでは。

[thkana]

え? 結局「なにが原因だった」のですか? ちゃんと筋道が通る説明はあるのですか?

[yu_89]

thkana様
ご回答いただき、ありがとうございます。また、返信が遅れてしまい、申し訳ございません。

>そのサンプルでSegmentation faultが出ているのですよね?
いえ、エラーが出ていたのは手元にある元のコードです。質問の主旨としてはmallocの使いすぎが原因でエラーが出るのか、ということをお聞きしたかったので、それに必要だと考えられる部分を抜き出して提示しました。しかし、やはり質問する以上、元のコードも提示するべきでしたね。申し訳ございません。元のコードも提示しておきます。

>どちらも実行できた、と書いてありますが正しいですか?
はい、正しいです。試した結果、それで動くようになりました。

> gccを一体どれだけの人が使っているかを考えると、この程度のプログラムで誤動作が起こるというのは宝くじの特等を連続で引くよりレアなことと思います。
なるほど、やはりmallocの使いすぎによる誤作動は考えにくいですかね。

>結局「なにが原因だった」
スタックサイズを変更して実行した所、セグメンテーションフォルトしたので、ローカル変数の使いすぎによるものだったと考えました。

[yu_89]

元のコードは省ききれなかったため、提示するのを断念します。申し訳ございません。

[thkana]

https://teratail.com/help/question-tips#questionTips35
「最も良いのは、現象を再現するためのミニマムなプログラムを改めて作ることです。」

スタックサイズを変化することで現象が出たり出なかったりする、というのはとても有力な情報であるのは確かですが、それ「だけ」が原因であったとすれば
> #defineで定義しても実行することができました。
は説明できるのでしょうか?
説明できないとすれば、地雷がちらと見えたのに土を被せて見なかったことにするような行為かも知れません。

[Zuishin]

スタックサイズが十分あると思われた時に発生した問題なので、スタックサイズを小さくして同じエラーが出たというのは解決の何の根拠にもなっていません。
ベストアンサーに選ばれているのもスタックと無関係のものだし、質問自体からも思い込みの強さが感じられます。

回答者が自分にマウントを取るために重箱の隅をつついて言わなくていいことをゴチャゴチャ言っているくらいの認識なのでしょう。

[thkana]

質問者さんが「スタックサイズ」から思考が離れなくなってしまって、仮説に反するかも知れない情報を直視できないでいるのはそうなんだけど、それは多分、自分がコレだと思ったのと全然違うところに真の原因があったという「痛い目」を見たことがないという経験不足、スキル不足からくるものじゃないかと思うのです。

回答のコメントのやり取りでメモリ確保のチェックにさっと対応している辺り、素直な人という印象を私は持ちましたよ。

[melian]

先に述べました様に、現状のスタックの使用量は 690 KB 程度で、Ubuntu のデフォルトのスタックサイズは 8 MB です。なので、N の値を 1024 ではなく 13650 程度以上にするとセグメンテーションフォールトが発生します。

int N = 1024;
=>
int N = 13650;

憶測ですが、元々は N の値をかなり大きな値に設定していたのではないでしょうか。

[Zuishin]

質問には省略されている部分があるので、ハードコーディングされている数値が違っていると言うよりは省略されている部分を先に疑うべきかと。

[Zuishin]

セグメンテーション違反がスタックサイズでしか起こりえないなら話は別ですが、ここではそれは原因の可能性の一つにすぎず、しかも掲載されているコードや質問者の開示した情報のみから判断するなら、そこまで可能性が高いようには見えません。
なので、本当にそこで解決したと断定していいのかという話が今進んでいるところです。

[Zuishin]

繰り返しになりますが、同じエラーが起こることは同じ原因であることを証明しません。

[yu_89]

コードを文字数制限ギリギリまで可能な限り載せました。
Nは1024よりは大きくして実行したことはないので、その可能性はないと考えられます。
確かに少し考えれば、今回の場合はスタックサイズが十分あると考えられる状態でセグメンテーション違反が発生してるので、スタックサイズを小さくして試して出るのはエラーが出るのは、何の根拠にもなりませんよね。真の原因から目を背けてました。
ただ、今は問題なく動いているので、ここからどうやってエラーが出た原因を探ればいいのか考えあぐねています。

[melian]

記載のコードにはファイルからデータを読み込む処理があるのですが、ファイルポインタが NULL がどうかをチェックしていません。引数に何も指定していなかったり、存在しないファイルを指定すれば、後の fgets() で segmentation fault が発生するでしょう。

fp = fopen(argv[1],"r");
fp1 = fopen(argv[2],"r");
　　:
fgets(datar, sizeof(datar), fp);
　　:
fgets(datai, sizeof(datai), fp1);

[yu_89]

ファイルポインタのNULLチェックをするのを忘れてました。
間違ったファイルを知らずに入力していたかもしれません。それも原因の一ですね。
入れておきます。ありがとうございます。

Answer 1

メモリを大量に使いすぎて、残りが足らなければ、mallocの実行が失敗することがあります。
mallocの実行時は、成功したか失敗したかを必ずチェックする必要がありますよ

Comments

[yu_89]

回答いただき、ありがとうございます。
確かにそうですね。メモリの確保に成功したか失敗したかの確認を怠っていました。
エラーになる理由を何時間も考えていたのですが、確認していれば、すぐに解決できたかもしれません。
次からは確認しながら使います。
ご助言、ありがとうございます。

[thkana]

> 次からは確認しながら使います。
だめです。
「今から」確認するプログラムにしましょう。

[yu_89]

そうですよね。「今から」すべきですよね。mallocでメモリの確保ができたかどうかを確認できるプログラムに変更して実行した所、メモリの確保ができていました。なので、やはり、ローカル変数の使いすぎによるエラーの可能性が大きいと考えます。

Answer 2

私の解答は間違っていました。すみません。

NULL for free しようとしているからではないですかね。

double* fq = NULL;　はアサインされてませんね。

Comments

[thkana]

NULLポインタに対するfree()は「なにもしない(エラーにもならない)」ことが保証されているはずです。

[NANASHI-TAROU]

double freeと混同してました。ご指摘ありがとうございます。

Answer 3

malloc() と free() を正しく使っていれば使い過ぎて誤動作するということはまずありません。質問文のコードでは malloc() の返り値チェックがないぐらいで、範囲外アクセスも見当たりませんので malloc() を使っていることが原因で問題が起きている可能性は極めて低いでしょう。

大量のローカル変数を使っていることがトラブルの原因になることがあります。ローカル変数はスタック上に確保されますが、スタックのサイズ限界はそんなに大きくないことがあります。スタックが枯渇していると、関数呼び出しをした瞬間にクラッシュするなどの症状が出ます。
Ubuntu でしたら、ulimit -s コマンドでスタックの最大サイズを知ることができます。大きな配列はグローバル変数にしたり、それこそ malloc() で確保するようにしましょう。

Comments

[yu_89]

ご回答いただき、ありがとうございます。
やはり、mallocが原因である可能性は低いですかね。
スタックサイズを変更して実行した所、セグメンテーションファルトになったので、やはりローカル変数の使いすぎによるエラーだったのかなと考えます。
グローバル変数にするかmallocで確保するようにします。