セグメテーションエラーの原因

Question

実現したいこと

セグメテーションエラーが特定の条件で出る原因を教えて欲しい

前提

並列化に関する課題です。完全に手詰まりしてます。

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

#define SIZE 1024
#define PRINT_SIZE 8

// matrix[row][col]
int a[SIZE][SIZE], b[SIZE][SIZE], c[SIZE][SIZE];

void init_a(int mat[SIZE][SIZE]){
	int row, col;
	for (row = 0 ; row < SIZE ; row++){
		for (col = 0 ; col < SIZE ; col++){
			mat[row][col] = row+1;
		}
	}
}
void init_b(int mat[SIZE][SIZE]){
	int row, col;
	for (row = 0 ; row < SIZE ; row++){
		for (col = 0 ; col < SIZE ; col++){
			mat[row][col] = row+col+1;
		}
	}
}

void print_matrix_sub(int mat[SIZE][SIZE], int size, int abbr, int start_row){
	int row, col;

	for (row = start_row ; row < start_row+size ; row++){
		for (col = 0 ; col < size ; col++){
			printf("%4d ", mat[row][col]);
		}
		if (abbr){
			printf(" ... ");
			for (col = SIZE-size ; col < SIZE ; col++){
				printf("%4d ", mat[row][col]);
			}

		}
		printf("\n");
	}
}

void print_matrix(int mat[SIZE][SIZE]){
	int size, abbr;

	if (SIZE > PRINT_SIZE){
		size = PRINT_SIZE/2;
		abbr = 1;
	}
	else {
		size = SIZE;
		abbr = 0;
	}

	print_matrix_sub(mat, size, abbr, 0);
	if (abbr){
		printf(" ...\n");
		print_matrix_sub(mat, size, abbr, SIZE-size);
	}
}

void matmul(int a[SIZE][SIZE], int b[SIZE][SIZE], int c[SIZE][SIZE]){
	int row, col, k, s;
	for (row = 0 ; row < SIZE ; row++){
		for (col = 0 ; col < SIZE ; col++){
			s = 0;
			for (k = 0 ; k < SIZE ; k++){
				s += a[row][k]*b[k][col];
			}
			c[row][col] = s;
		}
	}
}

int main(void){
	init_a(a);
	init_b(b);
	printf("A\n");
	print_matrix(a);
	printf("\nB\n");
	print_matrix(b);

	matmul(a, b, c);
	printf("\nC=AB\n");
	print_matrix(c);
	return 0;
}

SIZE×SIZEのある規則に則って生成された行列A、Bに対してC＝ABを求めるコードです。このコードはベースとなるもので、SIZEに定義する数字以外は手を加えません。このコードをpthread.hを用いて並列化する課題です。元のコードをベースに自分で書いたものが以下です。

gdbの結果受け修正したものをさらに下のトピックに載せます。

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

#define SIZE 1024
#define PRINT_SIZE 8
#define THREAD_NUM 2 //分割する数

#include <pthread.h>
typedef struct {
int start, end, ans[SIZE][SIZE];
} arg_t;//並列化に関わる構造体


// matrix[row][col]
int a[SIZE][SIZE], b[SIZE][SIZE], c[SIZE][SIZE];


//Aの生成を分割できるように変更
void init_a(int mat[SIZE][SIZE],int R_start,int R_end){
	int row, col;
	for (row = R_start ; row < R_end ; row++){
		for (col = 0 ; col < SIZE ; col++){
			mat[row][col] = row+1;
		}
	}
}
void init_b(int mat[SIZE][SIZE]){
	int row, col;
	for (row = 0 ; row < SIZE ; row++){
		for (col = 0 ; col < SIZE ; col++){
			mat[row][col] = row+col+1;
		}
	}
}

void print_matrix_sub(int mat[SIZE][SIZE], int size, int abbr, int start_row){
	int row, col;

	for (row = start_row ; row < start_row+size ; row++){
		for (col = 0 ; col < size ; col++){
			printf("%4d ", mat[row][col]);
		}
		if (abbr){
			printf(" ... ");
			for (col = SIZE-size ; col < SIZE ; col++){
				printf("%4d ", mat[row][col]);
			}

		}
		printf("\n");
	}
}

void print_matrix(int mat[SIZE][SIZE]){
	int size, abbr;

	if (SIZE > PRINT_SIZE){
		size = PRINT_SIZE/2;
		abbr = 1;
	}
	else {
		size = SIZE;
		abbr = 0;
	}

	print_matrix_sub(mat, size, abbr, 0);
	if (abbr){
		printf(" ...\n");
		print_matrix_sub(mat, size, abbr, SIZE-size);
	}
}

//不要な部分は計算しない。
void matmul(int a[SIZE][SIZE], int b[SIZE][SIZE], int c[SIZE][SIZE],int start,int end){
	int row, col, k, s;
	for (row = start ; row < end ; row++){
		for (col = 0 ; col < SIZE ; col++){
			s = 0;
			for (k = 0 ; k < SIZE ; k++){
				s += a[row][k]*b[k][col];
			}
			c[row][col] = s;
		}
	}
}

//最後にスレッド合流後にｃに格納するために追加。
void Assmat(int vessel[SIZE][SIZE],int element[SIZE][SIZE],int start,int end){
    int row,col;
    for (row = start ; row < end ; row++){
		for (col = 0 ; col < SIZE ; col++){
			vessel[row][col] = element[row][col];
		}
	}
    
}

//スレッドで動かす関数
void *f(void *varg){
    int tmp_a[SIZE][SIZE],tmp_b[SIZE][SIZE];
    arg_t *arg = (arg_t *)varg;
    init_a(tmp_a,arg->start,arg->end);
    init_b(tmp_b); 
    matmul(tmp_a,tmp_b,arg->ans,arg->start,arg->end);
    return NULL;
}


int main(void){
    int i;
	init_a(a,0,SIZE);
	init_b(b);
	printf("A\n");
	print_matrix(a);
	printf("\nB\n");
	print_matrix(b);
	pthread_t th[THREAD_NUM];
	arg_t arg[THREAD_NUM];
	for(i = 0;i < THREAD_NUM;i++){
	    arg[i].start = i*(SIZE/THREAD_NUM);
	    arg[i].end = (i+1)*(SIZE/THREAD_NUM);
	    //printf("%d to %d\n",arg[i].start,arg[i].end);//デバッグ用の出力
	    pthread_create(&th[i],NULL,f,&arg[i]);
	}
	for(i = 0; i<THREAD_NUM; i++){
	    pthread_join(th[i],NULL);
	    Assmat(c,arg[i].ans,arg[i].start,arg[i].end);
	}
	printf("\nC = AB\n");
	print_matrix(c);
	return 0;
}

SIZEやTHREAD_NUMを調整し、元のコードとの実行時間の違いを取るのが最終目標になります。
ggc -Wall -lpthreadでのコンパイルは通過してます。ただSIZEを大きくするとセグメンテーションエラーが出ます。具体的に境界値を探せていませんが、500程度なら出力でき、1000はセグメ出ます。元のコードは1024でも出力可能です。
セグメテーションエラーの原因を教えて頂きたいです。

自力でできなかった理由（コメントのおかげで解決しました！）

gdbを使って自力での特定を試みたのですが-gでコンパイルしてもディレクトリにcoreファイルが見つからない→そもそもコアダンプがでない（ただSegmentation faultのみ表示）→ulimitのコマンドが見つからないと言われるといった状態でこっちも手詰まりです…。セグメの原因追及と同時に、こちらも色々調べてる最中です。

gdbの結果受け修正

(gdb) frame 0
#0 0x0000000000400a49 in main () at matmul-th.c:108
108 init_a(a,0,SIZE);
けっきょく何がダメなのからず。ただinit_aは仕様変更する必要無いことに気づき、元のコードのものをそのまま使用。合わせて一部変更

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

#define SIZE 1000
#define PRINT_SIZE 8
#define THREAD_NUM 4

#include <pthread.h>
typedef struct {
int start, end, ans[SIZE][SIZE];
} arg_t;


// matrix[row][col]
int a[SIZE][SIZE], b[SIZE][SIZE], c[SIZE][SIZE];

//分割なし。aを一個だけ生成して範囲指定して使う。
void init_a(int mat[SIZE][SIZE]){
	int row, col;
	for (row = 0 ; row < SIZE ; row++){
		for (col = 0 ; col < SIZE ; col++){
			mat[row][col] = row+1;
		}
	}
}
void init_b(int mat[SIZE][SIZE]){
	int row, col;
	for (row = 0 ; row < SIZE ; row++){
		for (col = 0 ; col < SIZE ; col++){
			mat[row][col] = row+col+1;
		}
	}
}

void print_matrix_sub(int mat[SIZE][SIZE], int size, int abbr, int start_row){
	int row, col;

	for (row = start_row ; row < start_row+size ; row++){
		for (col = 0 ; col < size ; col++){
			printf("%4d ", mat[row][col]);
		}
		if (abbr){
			printf(" ... ");
			for (col = SIZE-size ; col < SIZE ; col++){
				printf("%4d ", mat[row][col]);
			}

		}
		printf("\n");
	}
}

void print_matrix(int mat[SIZE][SIZE]){
	int size, abbr;

	if (SIZE > PRINT_SIZE){
		size = PRINT_SIZE/2;
		abbr = 1;
	}
	else {
		size = SIZE;
		abbr = 0;
	}

	print_matrix_sub(mat, size, abbr, 0);
	if (abbr){
		printf(" ...\n");
		print_matrix_sub(mat, size, abbr, SIZE-size);
	}
}

void matmul(int a[SIZE][SIZE], int b[SIZE][SIZE], int c[SIZE][SIZE],int start,int end){
	int row, col, k, s;
	for (row = start ; row < end ; row++){
		for (col = 0 ; col < SIZE ; col++){
			s = 0;
			for (k = 0 ; k < SIZE ; k++){
				s += a[row][k]*b[k][col];
			}
			c[row][col] = s;
		}
	}
}

void Assmat(int vessel[SIZE][SIZE],int element[][SIZE],int start,int end){
    int row,col;
    for (row = start ; row < end ; row++){
		for (col = 0 ; col < SIZE ; col++){
			vessel[row][col] = element[row][col];
		}
	}
    
}

void *f(void *varg){
    arg_t *arg = (arg_t *)varg;
    //tmpは不要になったので削除
    matmul(a,b,arg->ans,arg->start,arg->end);
    return NULL;
}

int main(void){
    int i;
	init_a(a);
	init_b(b);
	printf("A\n");
	print_matrix(a);
	printf("\nB\n");
	print_matrix(b);
	pthread_t th[THREAD_NUM];
	arg_t arg[THREAD_NUM];
	for(i = 0;i < THREAD_NUM;i++){
	    arg[i].start = i*(SIZE/THREAD_NUM);
	    arg[i].end = (i+1)*(SIZE/THREAD_NUM);
	    //printf("%d to %d\n",arg[i].start,arg[i].end);
	    pthread_create(&th[i],NULL,f,&arg[i]);
	}
	for(i = 0; i<THREAD_NUM; i++){
	    pthread_join(th[i],NULL);
	    Assmat(c,arg[i].ans,arg[i].start,arg[i].end);
	}
	printf("\nC = AB\n");
	print_matrix(c);
	return 0;
}

ただし状況変わらずです…。SIZEが大きいとセグメですし、やっぱりinit_a(a)が原因だと言われます。元のコードが大丈夫なのもよく分からないです…。

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

OSはlinuxです。ただ学校配布の物をそのまま使ってるので詳しい環境設定は分かりません。

Comments

[melian]

ログインシェルが bash や zsh の場合、ulimit はビルトインコマンドなので、「ulimit のコマンドが見つからない」というエラーは発生しません。ログインシェルは何をお使いでしょうか？
ちなみに、

ulimit -c unlimited

をコマンドライン上で実行すれば core ファイルのサイズの制限を取り払ってくれます。

※ 追記
csh や tcsh ではビルトインコマンドの limit を使う様です。

limit coredumpsize unlimited

[jbpb0]

> ulimitのコマンドが見つからない

シェルは何でしょうか？
http://x68000.q-e-d.net/~68user/unix/pickup?ulimit

[daiwa]

/bin/tcshらしいです

[tmp]

関数fの
int tmp_a[SIZE][SIZE],tmp_b[SIZE][SIZE];
がスタックを8MB近く使っているので、恐らくスタックのサイズは、8MBなのでオーバーしたのかと思います。

[daiwa]

gdbが使えるようになりました！ありがとうございます。
その結果main内のinit_a(a,0,SIZE);が原因だというところまでたどり着けました。
ただそれでも原因が分からなかったため、コード全体を見直しわざわざaを分割して生成する意味がないと思い、関わる部分を全体的に修正しました。
ただなぜセグメなのかは分かんないままです…

[退会済みユーザー]

tmpさんの言う通り、stackが足りないだけですよ。
具体的には元のコード101行と元のコード119行です。
元のコード119行のargはグローバル変数にしちゃうと楽です。
必要ないかもしれませんが、元のコード101行でtmp_a, tmp_bをmallocで確保するコードは
int (*tmp_a)[SIZE] = malloc(SIZE * sizeof(*tmp_a));
int (*tmp_b)[SIZE] = malloc(SIZE * sizeof(*tmp_b));
と書けます。

[退会済みユーザー]

shellの設定はなくともcommand lineでgdbが使えれば
$ gdb 実行可能ファイル
> run
とかで普通にデバッグできます。IDEを使うと楽です。

[daiwa]

>>dameoさん
修正前のコードでtmp_a,tmp_bについてmallocで動的にメモリ確保したのち、使用終わり（matmulした直後）にそれぞれfreeすることでセグメ抜けました！スタック不足を指摘してくださったtmpさんもありがとうございます。課題として提出するには充分なのですが、自学のため追加で質問よろしいでしょうか？
①arg_t arg[THREAD_NUM]をmainの外に出すのと出さないのではどういった差が考えられますか？
②修正後コードのセグメとして考えられる原因はありますか？こちらはtmp_a,tmp_bをそもそも生成しません。

[退会済みユーザー]

ローカルに宣言された変数は基本的にスタックから確保されます。スタックはプロセスやスレッドごとに使えるサイズに制限があり、しかもあまり大きくないので、まとまった量を動的に確保するときはすぐにスタックがオーバーフローします。gccなどではこれをなるべく早く検出させるために、意図的に関数呼び出し時にセグメンテーションフォルトが起きるようなコードが生成されています。スタックがオーバーフローする場合は、ヒープからmallocで確保するか、ローカル変数をstaticに確保するか、グローバル変数にしてスタックの消費を削ります。
①グローバル変数になるのでスタックの消費が抑えられます。
②現象を見てないので分かりません。正確に報告してください。

[melian]

> ①arg_t arg[THREAD_NUM]をmainの外に出すのと出さないのではどういった差が考えられますか？

main 関数内にあると、arg はスタックに確保されます。Linux の場合、スタックのサイズはデフォルトで 8M bytes なので、結果的に stack overflow が発生します。(gcc の AddressSanitizer で検出可能)

グローバル変数化や malloc(3) でヒープ領域に確保する以外に、先の limit を使用してスタックサイズを拡張する方法があります。具体的にはコマンドライン(tcsh)で以下を実行すると、スタックサイズが 40 MB になります。

limit stacksize 41960

この状態でプログラムを実行すると結果が表示されて正常終了します。

[daiwa]

回答ありがとうございます。

Answer 1

原因

スタックのオーバーフローです。

調査

gdbを使った調査

問題のコードをgdbで動作させると、以下のようになります。

root:/src# gcc -g -pthread -Wall hoge.c -o hoge
root:/src# gdb hoge
GNU gdb (Debian 13.1-3) 13.1
...
(gdb) run
run
Starting program: /src/hoge 
warning: Error disabling address space randomization: Operation not permitted
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Program received signal SIGSEGV, Segmentation fault.
0x00000000004014ef in main () at hoge.c:105
105         init_a(a);
(gdb) list
100         return NULL;
101     }
102
103     int main(void){
104         int i;
105         init_a(a);
106         init_b(b);
107         printf("A\n");
108         print_matrix(a);
109         printf("\nB\n");
(gdb) disassemble
Dump of assembler code for function main:
   0x00000000004014df <+0>:     push   %rbp
   0x00000000004014e0 <+1>:     mov    %rsp,%rbp
   0x00000000004014e3 <+4>:     sub    $0xf42450,%rsp
   0x00000000004014ea <+11>:    mov    $0x404060,%edi
=> 0x00000000004014ef <+16>:    call   0x401166 <init_a>
...
(gdb) 

セグメンテーションフォルトを起こして落ちているのが分かります。アセンブラからはcall命令で関数init_a()に飛ぼうとしてるところで起きています。この命令はスタックに現在のripレジスタの値を積んでからジャンプするので、現在のスタック(rspレジスタ)が領域外を指していることが予想されます。

(gdb) info proc mappings
process 276
Mapped address spaces:

          Start Addr           End Addr       Size     Offset  Perms  objfile
            0x400000           0x401000     0x1000        0x0  r--p   /src/hoge
...
      0x7ffe21673000     0x7ffe21694000    0x21000        0x0  rw-p   [stack]
...
(gdb) info registers
...
rsp            0x7ffe2074fbd0      0x7ffe2074fbd0
...
rip            0x4014ef            0x4014ef <main+16>
...
(gdb) 

案の定、スタックに割り当てられている領域0x7ffe21673000～0x7ffe21694000を下回る0x7ffe2074fbd0にrspが下がっています。この領域には何も割当がないため、セグメンテーションフォルトが発生していました。

つまり、スタックがオーバーフローしていたということです。

gccのオプションを使った調査

スタックオーバーフローやメモリ破壊、リークが疑わしい場合、gccのオプションを使うことで効率的にチェックすることができます。-fsanitize=addressと-fsanitize=leakです。詳細はググってください。
これらを使用すると、アセンブラコードやレジスタを調べなくても現象を追うことができます。

root:/src# gcc -g -pthread -Wall -fsanitize=address -fsanitize=leak hoge.c -o hoge
root:/src# ./hoge 
AddressSanitizer:DEADLYSIGNAL
=================================================================
==284==ERROR: AddressSanitizer: stack-overflow on address 0x7ffff33bde00 (pc 0x00000040185a bp 0x7ffff4300390 sp 0x7ffff33bddf0 T0)
    #0 0x40185a in main /src/hoge.c:103                                                                                                                                                      
    #1 0x7f6a5051a1c9 in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58
    #2 0x7f6a5051a284 in __libc_start_main_impl ../csu/libc-start.c:360
    #3 0x401110 in _start (/src/hoge+0x401110)

SUMMARY: AddressSanitizer: stack-overflow /src/hoge.c:103 in main
==284==ABORTING
root:/src# 

ちゃんとスタックオーバーフローを検出してくれています。

あとはmain関数内で大きなローカル変数を探せば終わりです。コードを読めば一目瞭然で大きいのはargsですね。

対策

グローバル変数へ

--- a/hoge.c
+++ b/hoge.c
@@ -100,6 +100,8 @@ void *f(void *varg){
     return NULL;
 }
 
+arg_t arg[THREAD_NUM];
+
 int main(void){
     int i;
     init_a(a);
@@ -109,7 +111,6 @@ int main(void){
     printf("\nB\n");
     print_matrix(b);
     pthread_t th[THREAD_NUM];
-    arg_t arg[THREAD_NUM];
     for(i = 0;i < THREAD_NUM;i++){
         arg[i].start = i*(SIZE/THREAD_NUM);
         arg[i].end = (i+1)*(SIZE/THREAD_NUM);

ローカル変数のまま静的確保

--- a/hoge.c
+++ b/hoge.c
@@ -109,7 +109,7 @@ int main(void){
     printf("\nB\n");
     print_matrix(b);
     pthread_t th[THREAD_NUM];
-    arg_t arg[THREAD_NUM];
+    static arg_t arg[THREAD_NUM];
     for(i = 0;i < THREAD_NUM;i++){
         arg[i].start = i*(SIZE/THREAD_NUM);
         arg[i].end = (i+1)*(SIZE/THREAD_NUM);

ヒープから動的に確保

--- a/hoge.c
+++ b/hoge.c
@@ -109,7 +109,7 @@ int main(void){
     printf("\nB\n");
     print_matrix(b);
     pthread_t th[THREAD_NUM];
-    arg_t arg[THREAD_NUM];
+    arg_t *arg = malloc(THREAD_NUM * sizeof(*arg));
     for(i = 0;i < THREAD_NUM;i++){
         arg[i].start = i*(SIZE/THREAD_NUM);
         arg[i].end = (i+1)*(SIZE/THREAD_NUM);
@@ -122,5 +122,6 @@ int main(void){
     }
     printf("\nC = AB\n");
     print_matrix(c);
+    free(arg);
     return 0;
 }

いずれにしても、問題は発生しなくなります。

スタックサイズの確認方法・調整方法

Linuxではスタックサイズは、基本的にシェルが管理しています。当該シェルでスタックサイズを確認してください。
ただし、ここで決められるのはプロセスのスタックサイズだけで、スレッドごとに割り当てられるスタックサイズはまた別にあり、シェルの管理外なので注意してください。Linuxのpthreadに限定すれば、このサイズはプログラム側で決められるもので、amd64だとデフォルトでは2MBになります。

いずれにしてもこれらのサイズは環境依存なので、なるべく大きなサイズのデータをローカルで確保しないように心掛ける方が賢明です。

確認用のコード

要docker&bash

cat >hoge.c <<EOF
#include <stdio.h>
#include <stdlib.h>
#include<pthread.h>

#define SIZE 1000
#define PRINT_SIZE 8
#define THREAD_NUM 4

#include <pthread.h>
typedef struct {
int start, end, ans[SIZE][SIZE];
} arg_t;


// matrix[row][col]
int a[SIZE][SIZE], b[SIZE][SIZE], c[SIZE][SIZE];

//分割なし。aを一個だけ生成して範囲指定して使う。
void init_a(int mat[SIZE][SIZE]){
    int row, col;
    for (row = 0 ; row < SIZE ; row++){
        for (col = 0 ; col < SIZE ; col++){
            mat[row][col] = row+1;
        }
    }
}
void init_b(int mat[SIZE][SIZE]){
    int row, col;
    for (row = 0 ; row < SIZE ; row++){
        for (col = 0 ; col < SIZE ; col++){
            mat[row][col] = row+col+1;
        }
    }
}

void print_matrix_sub(int mat[SIZE][SIZE], int size, int abbr, int start_row){
    int row, col;

    for (row = start_row ; row < start_row+size ; row++){
        for (col = 0 ; col < size ; col++){
            printf("%4d ", mat[row][col]);
        }
        if (abbr){
            printf(" ... ");
            for (col = SIZE-size ; col < SIZE ; col++){
                printf("%4d ", mat[row][col]);
            }

        }
        printf("\n");
    }
}

void print_matrix(int mat[SIZE][SIZE]){
    int size, abbr;

    if (SIZE > PRINT_SIZE){
        size = PRINT_SIZE/2;
        abbr = 1;
    }
    else {
        size = SIZE;
        abbr = 0;
    }

    print_matrix_sub(mat, size, abbr, 0);
    if (abbr){
        printf(" ...\n");
        print_matrix_sub(mat, size, abbr, SIZE-size);
    }
}

void matmul(int a[SIZE][SIZE], int b[SIZE][SIZE], int c[SIZE][SIZE],int start,int end){
    int row, col, k, s;
    for (row = start ; row < end ; row++){
        for (col = 0 ; col < SIZE ; col++){
            s = 0;
            for (k = 0 ; k < SIZE ; k++){
                s += a[row][k]*b[k][col];
            }
            c[row][col] = s;
        }
    }
}

void Assmat(int vessel[SIZE][SIZE],int element[][SIZE],int start,int end){
    int row,col;
    for (row = start ; row < end ; row++){
        for (col = 0 ; col < SIZE ; col++){
            vessel[row][col] = element[row][col];
        }
    }
    
}

void *f(void *varg){
    arg_t *arg = (arg_t *)varg;
    //tmpは不要になったので削除
    matmul(a,b,arg->ans,arg->start,arg->end);
    return NULL;
}

int main(void){
    int i;
    init_a(a);
    init_b(b);
    printf("A\n");
    print_matrix(a);
    printf("\nB\n");
    print_matrix(b);
    pthread_t th[THREAD_NUM];
    arg_t arg[THREAD_NUM];
    for(i = 0;i < THREAD_NUM;i++){
        arg[i].start = i*(SIZE/THREAD_NUM);
        arg[i].end = (i+1)*(SIZE/THREAD_NUM);
        //printf("%d to %d\n",arg[i].start,arg[i].end);
        pthread_create(&th[i],NULL,f,&arg[i]);
    }
    for(i = 0; i<THREAD_NUM; i++){
        pthread_join(th[i],NULL);
        Assmat(c,arg[i].ans,arg[i].start,arg[i].end);
    }
    printf("\nC = AB\n");
    print_matrix(c);
    return 0;
}
EOF
cat >global.diff <<EOF
diff --git a/hoge.c b/hoge.c
index 6df35aa..45d4e2b 100644
--- a/hoge.c
+++ b/hoge.c
@@ -100,6 +100,8 @@ void *f(void *varg){
     return NULL;
 }
 
+arg_t arg[THREAD_NUM];
+
 int main(void){
     int i;
     init_a(a);
@@ -109,7 +111,6 @@ int main(void){
     printf("\\nB\\n");
     print_matrix(b);
     pthread_t th[THREAD_NUM];
-    arg_t arg[THREAD_NUM];
     for(i = 0;i < THREAD_NUM;i++){
         arg[i].start = i*(SIZE/THREAD_NUM);
         arg[i].end = (i+1)*(SIZE/THREAD_NUM);
EOF
cat >static.diff <<EOF
diff --git a/hoge.c b/hoge.c
index 6df35aa..f68cf0f 100644
--- a/hoge.c
+++ b/hoge.c
@@ -109,7 +109,7 @@ int main(void){
     printf("\\nB\\n");
     print_matrix(b);
     pthread_t th[THREAD_NUM];
-    arg_t arg[THREAD_NUM];
+    static arg_t arg[THREAD_NUM];
     for(i = 0;i < THREAD_NUM;i++){
         arg[i].start = i*(SIZE/THREAD_NUM);
         arg[i].end = (i+1)*(SIZE/THREAD_NUM);
EOF
cat >malloc.diff <<EOF
diff --git a/hoge.c b/hoge.c
index 6df35aa..8712646 100644
--- a/hoge.c
+++ b/hoge.c
@@ -109,7 +109,7 @@ int main(void){
     printf("\\nB\\n");
     print_matrix(b);
     pthread_t th[THREAD_NUM];
-    arg_t arg[THREAD_NUM];
+    arg_t *arg = malloc(THREAD_NUM * sizeof(*arg));
     for(i = 0;i < THREAD_NUM;i++){
         arg[i].start = i*(SIZE/THREAD_NUM);
         arg[i].end = (i+1)*(SIZE/THREAD_NUM);
@@ -122,5 +122,6 @@ int main(void){
     }
     printf("\nC = AB\n");
     print_matrix(c);
+    free(arg);
     return 0;
 }
EOF
docker run -i --rm -v `pwd`:/src/ gcc:12 bash <<EOF
apt-get update
apt-get install -y gdb
cd src
gcc -g -pthread -Wall hoge.c -o hoge
gdb ./hoge
run
list
disassemble
info proc mappings
info registers
continue
quit
gcc -g -pthread -Wall -fsanitize=address -fsanitize=leak hoge.c -o hoge
./hoge
patch -p1 <global.diff
gcc -g -pthread -Wall -fsanitize=address -fsanitize=leak hoge.c -o hoge
./hoge
patch -p1 -R <global.diff
patch -p1 <static.diff
gcc -g -pthread -Wall -fsanitize=address -fsanitize=leak hoge.c -o hoge
./hoge
patch -p1 -R <static.diff
patch -p1 <malloc.diff
gcc -g -pthread -Wall -fsanitize=address -fsanitize=leak hoge.c -o hoge
./hoge
patch -p1 -R <malloc.diff
exit
EOF

Comments

[daiwa]

gdbの解説から、解析結果から分かる原因とその回避方法までご丁寧にありがとうございます。
スタックの大きさを意識することが無かったので見解が広がりました。

Answer 2

C言語のプログラムでは、実行時のエラーチェックは全く行われません。
たとえアクセス違反があろうと、いかなるバグがあろうとそれで暴走しようが、それは全くチェックされず実行を続けます

では、なぜ実行時にエラーが出るのか、というと、どこかでアクセス違反があるコードを実行したために、その後のコード実行において何らかの動作異常を、OSのカーネルが検出したために、OSの動作異常として表に出てきます。
C言語のコードの異常、ではなくて、OSの動作異常というところがポイントです。

ってことで、いくらGDBでステップ実行してこのタイミングでエラーが出た、といってもたまたまこのタイミングでエラーが顕在化した、というだけでその場所で異常が起こったとは限りません。

ってことで、いくらデバッガを使ったところで、エラーの場所を特定することはできない、ってことに注意しましょう

Comments

[daiwa]

デバッガ―の仕様について大きな誤解があったみたいです。ありがとうございます。