Tableau global initialisé

Version imprimable

31/05/2010, 00h12
Pouet_forever

Tableau global initialisé
Bonjour à tous.

Dernièrement j'ai découvert quelque chose qui m'a surpris.
En déclarant un tableau global et en l'initialisant, il se trouve que mon exécutable grossi en fonction de la taille de ce tableau et le temps de compilation est, lui aussi, fortement augmenté.
Si je n'initialise pas ce tableau, rien de bien particulier, tout se passe bien.

Voilà le code incriminé (gros tableau pour bien montrer le problème) :
Code:

1 2 3 4 5 6 7 8 9 #include <stdio.h> #include <stdlib.h> int tab[1000][1000][100] = {{{ 0 }}}; int main(void) { return EXIT_SUCCESS; }
Sur linux avec gcc, ou win avec mingw je n'ai aucun problème, tandis que quand je fais ça avec gcc sous Mac... le problème se pose.

Version GCC : gcc version 4.2.1 (Apple Inc. build 5646) (dot 1)

Quelqu'un aurait-il une idée ? :)

Merci d'avance.
01/06/2010, 01h17
LittleWhite

Bonjour,

Je sais deux trois choses, mais je ne comprends pas trop pourquoi vous avez le problème que sous MAC... en partant du principe que le problème est la taille de l'executable.

Un tableau statique se met dans la pile. La pile est un morceau de mémoire qui est chargé directement à partir du programme. ( En assembleur, je crois que c'est le segment .DATA )
Lorsque l'on fait l'initialisation directement dans le programme ( explicitement ) je pense que le compilateur doit préparé tout le segment dans l'executable. Donc remplissage d'une bonne partie.
Après, que l'effet soit sous MAC seulement, il y a plusieurs cas, premièrement, une optimisation possible car vous demander un remplissage avec 0 ( peut être que c'est 0 par defaut et que le compilateur triche ). Sinon, peut être car les fichiers sous Windows / Linux sont compressés ( optimisés ).
Je ne sais pas trop dans le détails, et j'ai pu dire des bétises :s
01/06/2010, 15h05
Obsidian

Si tu initialises le tableau, qu'il soit dans la pile ou en global, les données servant à le remplir doivent être écrites en dur dans le code de ton programme pour y être copiées à l'exécution. Si tu déclares un tableau géant, les données associées le sont tout autant.

Après, gcc est effectivement capable d'optimiser la chose si les données sont redondantes. Pourquoi ça ne marche pas sous Mac, mystère, effectivement.
01/06/2010, 17h14
gangsoleil

Bonjour,

Le plus simple(*) est de regarder le code assembleur généré, voir de le passer dans un profiler de code pour savoir dans quelles parties il passe le plus de temps.

Le fait de répéter cette opération sur différents OS te permettra de trouver la source de ton soucis.

(*) : Oui oui, c'est simple, même si ca demande de comprendre plusieurs langages assembleurs :)

Sous mac, si on tableau est initialisé il met 'tab' dans le segment 'data' directement et n'alloue pas la taille du tableau mais 4 fois la taille du tableau...
Non initialisé il met ça sur la pile.

Pour Linux :
- non initialisé : pile
- initialisé à 0 : bss
- initialisé avec autre chose que 0 : data et l'exécutable grossi énormement. ^^

Que ce soit Linux ou Mac, ils allouent tous deux 4 fois la taille du tableau.

Voilà l'asm de chaque, pour voir si je me suis pas planté. :aie:

Mac, tab non initialisé :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
	.text
.globl _main
_main:
LFB6:
	pushq	%rbp
LCFI0:
	movq	%rsp, %rbp
LCFI1:
	movl	$0, %eax
	leave
	ret
LFE6:
.comm _tab,400000000,5
	.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
EH_frame1:
	.set L$set$0,LECIE1-LSCIE1
	.long L$set$0
LSCIE1:
	.long	0x0
	.byte	0x1
	.ascii "zR\0"
	.byte	0x1
	.byte	0x78
	.byte	0x10
	.byte	0x1
	.byte	0x10
	.byte	0xc
	.byte	0x7
	.byte	0x8
	.byte	0x90
	.byte	0x1
	.align 3
LECIE1:
.globl _main.eh
_main.eh:
LSFDE1:
	.set L$set$1,LEFDE1-LASFDE1
	.long L$set$1
LASFDE1:
	.long	LASFDE1-EH_frame1
	.quad	LFB6-.
	.set L$set$2,LFE6-LFB6
	.quad L$set$2
	.byte	0x0
	.byte	0x4
	.set L$set$3,LCFI0-LFB6
	.long L$set$3
	.byte	0xe
	.byte	0x10
	.byte	0x86
	.byte	0x2
	.byte	0x4
	.set L$set$4,LCFI1-LCFI0
	.long L$set$4
	.byte	0xd
	.byte	0x6
	.align 3
LEFDE1:
	.subsections_via_symbols

Linux non initialisé :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
	.file	"main.c"
.globl tab
	.data
	.align 32
	.type	tab, @object
	.size	tab, 400000000
tab:
	.long	1
	.zero	396
	.zero	399600
	.zero	399600000
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$0, %eax
	popl	%ebp
	ret
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.1-4ubuntu9) 4.4.1"
	.section	.note.GNU-stack,"",@progbits
nico@ubuntu:~/Bureau$ gcc -S main.c
nico@ubuntu:~/Bureau$ cat main.s
	.file	"main.c"
	.comm	tab,400000000,32
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$0, %eax
	popl	%ebp
	ret
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.1-4ubuntu9) 4.4.1"
	.section	.note.GNU-stack,"",@progbits

Mac initialisé à 0 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
.globl _tab
	.data
	.align 5
_tab:
	.space 400000000
	.text
.globl _main
_main:
LFB6:
	pushq	%rbp
LCFI0:
	movq	%rsp, %rbp
LCFI1:
	movl	$0, %eax
	leave
	ret
LFE6:
	.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
EH_frame1:
	.set L$set$0,LECIE1-LSCIE1
	.long L$set$0
LSCIE1:
	.long	0x0
	.byte	0x1
	.ascii "zR\0"
	.byte	0x1
	.byte	0x78
	.byte	0x10
	.byte	0x1
	.byte	0x10
	.byte	0xc
	.byte	0x7
	.byte	0x8
	.byte	0x90
	.byte	0x1
	.align 3
LECIE1:
.globl _main.eh
_main.eh:
LSFDE1:
	.set L$set$1,LEFDE1-LASFDE1
	.long L$set$1
LASFDE1:
	.long	LASFDE1-EH_frame1
	.quad	LFB6-.
	.set L$set$2,LFE6-LFB6
	.quad L$set$2
	.byte	0x0
	.byte	0x4
	.set L$set$3,LCFI0-LFB6
	.long L$set$3
	.byte	0xe
	.byte	0x10
	.byte	0x86
	.byte	0x2
	.byte	0x4
	.set L$set$4,LCFI1-LCFI0
	.long L$set$4
	.byte	0xd
	.byte	0x6
	.align 3
LEFDE1:
	.subsections_via_symbols

Linux initialisé à 0 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
	.file	"main.c"
.globl tab
	.bss
	.align 32
	.type	tab, @object
	.size	tab, 400000000
tab:
	.zero	400000000
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$0, %eax
	popl	%ebp
	ret
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.1-4ubuntu9) 4.4.1"
	.section	.note.GNU-stack,"",@progbits

Mac initialisé à 1 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
.globl _tab
	.data
	.align 5
_tab:
	.long	1
	.space 396
	.space 399600
	.space 399600000
	.text
.globl _main
_main:
LFB6:
	pushq	%rbp
LCFI0:
	movq	%rsp, %rbp
LCFI1:
	movl	$0, %eax
	leave
	ret
LFE6:
	.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
EH_frame1:
	.set L$set$0,LECIE1-LSCIE1
	.long L$set$0
LSCIE1:
	.long	0x0
	.byte	0x1
	.ascii "zR\0"
	.byte	0x1
	.byte	0x78
	.byte	0x10
	.byte	0x1
	.byte	0x10
	.byte	0xc
	.byte	0x7
	.byte	0x8
	.byte	0x90
	.byte	0x1
	.align 3
LECIE1:
.globl _main.eh
_main.eh:
LSFDE1:
	.set L$set$1,LEFDE1-LASFDE1
	.long L$set$1
LASFDE1:
	.long	LASFDE1-EH_frame1
	.quad	LFB6-.
	.set L$set$2,LFE6-LFB6
	.quad L$set$2
	.byte	0x0
	.byte	0x4
	.set L$set$3,LCFI0-LFB6
	.long L$set$3
	.byte	0xe
	.byte	0x10
	.byte	0x86
	.byte	0x2
	.byte	0x4
	.set L$set$4,LCFI1-LCFI0
	.long L$set$4
	.byte	0xd
	.byte	0x6
	.align 3
LEFDE1:
	.subsections_via_symbols

Linux initialisé à 1 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
	.file	"main.c"
.globl tab
	.data
	.align 32
	.type	tab, @object
	.size	tab, 400000000
tab:
	.long	1
	.zero	396
	.zero	399600
	.zero	399600000
	.text
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	%esp, %ebp
	movl	$0, %eax
	popl	%ebp
	ret
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.1-4ubuntu9) 4.4.1"
	.section	.note.GNU-stack,"",@progbits

Quand je dis initialisé à 1 c'est uniquement ça : int tab[1000][1000][100] = {{{ 1 }}};

Merci. :)

01/06/2010, 18h43
ram-0000

Citation:

Envoyé par Pouet_forever

Sous mac, si on tableau est initialisé il met 'tab' dans le segment 'data' directement et n'alloue pas la taille du tableau mais 4 fois la taille du tableau...

Non, il alloue la taille du tableau * par sizeof(int) = 4 (probablement)
01/06/2010, 18h47
Pouet_forever

Bien vu. 8-)