Reducerea apelurilor

Reducerea apelurilor de funcții și de proceduri este benefic dacă și numai dacă are un rol de a compensa creșterea lungimii programului prin creșterea numărului de instrucțiuni din secvențe similare, care au justificat regruparea în subrutine.
Trebuie spus că la apelul unei subrutine, oricare ar fi tipul ei, se produc niște lucruri, care se concretizează prin cicluri mașină.
Într-un program fortran dacă se dorește să se calculeze patru medii aritmetice vom proceda astfel:
- scriem un subprogram de calcul pentru media aritmetică;
- apelăm subprogramul de patru ori schimbând parametrii:
- subprogramul realizează transferul de parametrii;
- subprogramul efectuează returnarea rezultatului;
- subprogramul efectuează reansfer la instrucțiunea următoare.
Probabil, pentru a evita salturile din apelator în subprogram și din subprogram în apelator, este mai rezonabil să se încorporeze inteligent instrucțiunile de calcul ale mediilor direct în apelator.Dacă voi scrie fără a apela subprograme, textul va fi:
             DIMENSION X(100), Y(100), Z(100), WW(100)
             INTEGER I, N
             INTEGER MEDX,MEDY,MEDZ,MEDW
             REAL SUMX, SUMY, SUMZ, SUMW
C          INITIALIZARI NUMAR COMPONENTE
C          INITIALIZARI SERII DE DATE
             SUMX=0
             SUMY=0
             SUMZ=0
             SUMW=0
........................................
             DO 50 I=1,N
             SUMX=SUMX+X(I) 
             SUMY=SUMX+Y(I) 
             SUMZ=SUMX+Z(I) 
50         SUMW=SUMX+W(I)
             SUMX=SUMX
             MEDX=SUMX /N
             MEDY=SUMY /N
             MEDZ=SUMZ /N
             MEDW=SUMW /N
..................................
C          INSTRUCTIUNI DE SCRIERE  A REZULTATELOR

Se observă că textul sursă este mai lunguț, dar nu conține niciun apel prin CALL și nico revenire în apelator prin RETURN, dar dacă mai se ține seama că suprobramele s-ar încărca în segmente diferite, salturile intersegment au un număr de cicluri mașină înfiorător de mari, lucru demonstrat în toate manualele de prezentare a limbajelor de asamblare, care se respectă și care intră în astfel de detalii.
Dacă ar fi să calculăm media folosind un subprogram acesta va avea forma:
C          SUBPROGRAM DE CALCUL MEDIE ARITMETICA
             SUBROUTINE MEDIA (X, N,XMED)
             DIMENSION X(N)
             INTEGER I
             REAL    SUM
             SUM=0
             DO 10  I=1,N
10         SUM=SUM+X(I)
             XMED=SUM/FLOAT(N)
             RETURN
             END
În acest text sursă variabilele X, N,XMED se numesc parametrii formali. Programul apelator va conține instrucțiunile:
             DIMENSION X(100), Y(100), Z(100), WW(100)
             INTEGER I, N
             INTEGER MEDX,MEDY,MEDZ,MEDW
             REAL SUMX, SUMY, SUMZ, SUMW
C          INITIALIZARI NUMAR COMPONENTE
C          INITIALIZARI SERII DE DATE

........................................
             CALL  (X, N,XMED)
             CALL  (Y, N,YMED)
             CALL  (Z, N,ZMED)
             CALL  (W, N,WMED)
..................................
C           INSTRUCȚIUNI DE SCRIERE MEDII: 
C           XMED,YMED, ZMED, WMED
Sunt situații unde așa ceva nu este rentabil. Programatorul va face evaluările astfel încât ceea ce obține să fie un program cât de cât eficient dacă a obține un program optim este prea pretențios. În celelalte limbaje tot cam așa stau lucrurile deși multe dintre proceduri se scriu direct nemaifiind necesară o instrucțiune de tip CALL ca pe vremuri, dar tot se produc salturi  necondiționate  la apel și la revenire chiar dacă sunt intersegment sau intrasegment tot hulitele  salturi necondiționate sunt.

(05 decembrie 2017)