Programowanie w systemie UNIX/Kompilacja

Z Wikibooks, biblioteki wolnych podręczników.
Przejdź do nawigacji Przejdź do wyszukiwania

Kompilacja[edytuj]

gcc - ręczna kompilacja[edytuj]

Jest kilka sposobów [1]


jeden plik[edytuj]

Najprostszy program

Najprostsza kompilacja: program = 1 plik. Plik z kodem programu, np. p.c skompiluj za pomocą komendy:

gcc p.c

Otrzymasz plik a.out (standardowa nazwa)

  • uruchom za pomocą:
./a.out


Możesz zmienić nazwę generowanego pliku. W tym celu skompiluj go za pomocą komendy:

gcc p.c -o p.out
  • uruchom za pomocą:
./p.out

Możesz włączyć wszystkie ostrzeżenia (ang. Warnings all)

gcc -Wall p.c

kilka plików[edytuj]

kilka plików programu[edytuj]

kilka plików programu
kilka plików programu

Możemy skompilować ręcznie:[2]

gcc -o executable sourcefile_1.c sourcefile_2.c ... sourcefile_n.c

biblioteki[edytuj]

Na przykładzie biblioteki matematycznej libm w wersji:

  • statycznej (zwykle /usr/lib/libm.a) i pliku nagłówkowym math.h (zwykle /usr/include/math.h)
  • ładowanej dynamicznie (/usr/lib/libm.so)

Aby skorzystać z tej biblioteki należy :

  • dodać w pliku p.c: #include <math.h>
  • w czasie kompilacji dołączyć bibliotekę libm: gcc p.c -lm

Narzędzia do kompilacji[edytuj]

Make[edytuj]

Program make jest nadzorcą kompilacji. Wykorzystuje plik reguł kompilacji nazywany zazwyczaj "makefile" i na jego podstawie decyduje które ze składników wielo-źródłowego programu muszą być skompilowane ponownie. Do oceny tego faktu używa pliku reguł i czasu modyfikacji plików. Aby skompilować swój program wprowadź komendę :

make

autoconf[edytuj]

Typowo:

./configure
make
make install

ale możliwa jest optymalizacja dla procesorów wielordzeniowych:[3]

./configure
make -j 2 # zamień 2 na liczbę rdzeni twojego procesora
make install


Automake[edytuj]

Automake czyta plik Makefile.am i tworzy plik Makefile.in

Ant[edytuj]

Apache Ant jest to narządzie do budowania programów [4]

Optymalizacja[edytuj]

Można przyspieszyć działanie programu przez odpowiednią kompilację [5] (opcje) i przetestowanie efektu. Np. dodanie opcji kompilacji:

-O3 -funroll-loops

lub

-O2

może dać 2-krotne skrócenie czasu wykonania programu. Porównaj efekty zaawansowanej optymalizacji tutaj [6]

Inne opcje:

-mtune=native 

generuje kod dostrojony do aktualnego procesora (na innym też się uruchomi).

-march=native

wykorzystuje wszystkie instrukcje używanego procesora (jeżeli inny procesor ich nie obsługuje, kod nie będzie działał).

Za pomocą instrukcji:

 gcc -O3 -Q --help=optimizers | grep disabled

sprawdzamy wszystkie wyłączone opcje. Przykładowy wynik:

  -fbranch-probabilities      		[disabled]
  -fbranch-target-load-optimize 	[disabled]
  -fbranch-target-load-optimize2 	[disabled]
  -fbtr-bb-exclusive          		[disabled]
  -fconserve-stack            		[disabled]
  -fcx-fortran-rules          		[disabled]
  -fcx-limited-range          		[disabled]
  -fdata-sections             		[disabled]
  -fdelayed-branch            		[disabled]
  -fexceptions                		[disabled]
  -ffinite-math-only          		[disabled]
  -ffloat-store               		[disabled]
  -fgcse-las                  		[disabled]
  -fgcse-sm                   		[disabled]
  -fgraphite-identity         		[disabled]
  -fipa-pta                   		[disabled]
  -floop-block                		[disabled]
  -floop-interchange          		[disabled]
  -floop-nest-optimize        		[disabled]
  -floop-parallelize-all      		[disabled]
  -floop-strip-mine           		[disabled]
  -fmerge-all-constants       		[disabled]
  -fmodulo-sched              		[disabled]
  -fnon-call-exceptions       		[disabled]
  -fnothrow-opt               		[disabled]
  -fomit-frame-pointer        		[disabled]
  -fopt-info                  		[disabled]
  -fpack-struct               		[disabled]
  -fpeel-loops                		[disabled]
  -freg-struct-return         		[disabled]
  -freorder-blocks-and-partition 	[disabled]
  -freschedule-modulo-scheduled-loops 	[disabled]
  -frounding-math             		[disabled]
  -fsched-pressure            		[disabled]
  -fsched-spec-load           		[disabled]
  -fsched-spec-load-dangerous 		[disabled]
  -fsched-stalled-insns       		[disabled]
  -fsched2-use-superblocks    		[disabled]
  -fschedule-insns            		[disabled]
  -fsection-anchors           		[disabled]
  -fsel-sched-pipelining      		[disabled]
  -fsel-sched-pipelining-outer-loops 	[disabled]
  -fsel-sched-reschedule-pipelined 	[disabled]
  -fselective-scheduling      		[disabled]
  -fselective-scheduling2     		[disabled]
  -fshort-double              		[disabled]
  -fshort-wchar               		[disabled]
  -fsignaling-nans            		[disabled]
  -fsingle-precision-constant 		[disabled]
  -fstrict-enums              		[disabled]
  -ftrapv                     		[disabled]
  -ftree-coalesce-inlined-vars 		[disabled]
  -ftree-loop-distribution    		[disabled]
  -ftree-loop-if-convert-stores 	[disabled]
  -ftree-lrs                  		[disabled]
  -funroll-all-loops          		[disabled]
  -funroll-loops              		[disabled]
  -funsafe-loop-optimizations 		[disabled]
  -funsafe-math-optimizations 		[disabled]
  -funwind-tables             		[disabled]
  -fvar-tracking-assignments-toggle 	[disabled]
  -fvar-tracking-uninit       		[disabled]
  -fvariable-expansion-in-unroller 	[disabled]
  -fvpt                       		[disabled]
  -fwhole-program             		[disabled]
  -fwrapv                     		[disabled]

Opcje obliczeń zmiennoprzecinkowych [7]

Testowanie programu[edytuj]

Są 2 metody: [8]

Program Time[edytuj]

gcc -o prog main.c
time prog

Przykład użycia:

Testujemy ile czasu zajmie 4000 razy wypisanie tekstu (przykładowy kod):

const int iXmax = 4000;
const int iYmax = 4000;
  for(iY=0;iY<iYmax;++iY)
   {
     printf("iY/iYmax =   %d / %d \n", iY, iYmax);
     for(iX=0;iX<iXmax;++iX){}
   }

Skompilowany:

  gcc s.c -lm

Uruchomiony:

  time ./a.out
  real    0m0.267s
  user    0m0.120s
  sys    0m0.040s

Jeśli usuniemy komendę printf:

real    0m0.150s
user    0m0.140s
sys    0m0.020s

Różnica około 0.150 sekundy

Program gprof[edytuj]

Opis gprof

Kompilacja z opcją -pg powoduje, że po wykonaniu skompilowanego programu zostaną zapisanie do pliku gmon.out czasy wykonania poszczególnych funkcji

gcc -o prog main.c -pg
./proggprof prog > test1.prof

lub

gcc -o prg source.c -pg
gprof prg > gprof.out

Zobacz również[edytuj]

Bibliografia[edytuj]

  1. Building C programs on Linux from LinuxQuestions.org
  2. Compiling-multiple-files - The GNU C Programming Tutorial
  3. Speed-up compile (make) time on dual-core (or multi-core) processor!
  4. Strona domowa Apache Ant
  5. Algorytmy przetwarzania obrazów i wstęp do pracy z biblioteką OpenCV Pod redakcją Ewarysta Rafajłowicza, Wojciecha Rafajłowicza i Andrzeja Rusieckiego
  6. The Computer Language Benchmarks Game
  7. Semantics of Floating Point Math in GCC
  8. gcc-function-for-find-execution-time - dyskusja na gamedev