Lungime sau volum de prelucrări

Când se scrie un program se fac multe calcule pentru a vedea care este varianta de program cea mai convenabilă. Se fac alegeri justificate cu destul de multe argumente, unele fiind foarte convingătoare. De regulă se construiesc modele de eficiență în care apar inegalități din care să rezulte când este bună o variantă și când este bună o altă variantă de program. Voi da un exemplu de astfel de analiză. Există o problemă P în care trebuie evaluate expresiile:

C = A + B

P = R + S

X = Y + Z

W = U + V

unde A, B, C, P, R, S, X, Y, Z, W, U și V sunt matrice cu diferite dimensiuni care permit totuși efectuarea operațiilor specifice acelor expresii, adică matricele A, B, C au fiecare M1 linii și N1, coloane, matricele P, R, S au fiecare câte M2 linii și N2 coloane, matricele X, Y, Z au fiecare M3 linii și N3 coloane, iar matricele W, U și V au respectiv M4 linii  și N4 coloane. Ideia de bază care se desprinde este aceea de a scrie un subprogram de adunare a două matrice, subprogram care va fi apelat de 4 ori, ceea ce duce la textul sursă următor:

            SUBROUTINE ADMAT(A,B,C,M,N)

            DO 10 I=1,M

            DO 10 J=1,N

            C(I,J)=A(I,J)+B(I,J)

10        CONTINUE

            RETURN

            END

Programul principal va conține:

................. secvență inițializare variabile M1, N1, M2, N2, M3, N3, M4, N4 .............

................. secvență inițializare matrice A, B .............

................. secvență inițializare matrice R, S .............

................. secvență inițializare matrice Y, Z .............

................. secvență inițializare matrice U, V .............

            CALL ADMAT(A,B,C,M1,N1)

            CALL ADMAT(R,S,P,M2,N2)

            CALL ADMAT(Y,Z,X,M3,N3)

            CALL ADMAT(U,V,W,M4,N4)

................. secvență cu alte prelucrări ale matricelor C, P, X și W.

Pentru ceea ce ne interesează să se optimizeze, textul sursă se referă la o construcție de lungime

Lg = 6 + 4 = 10 instrucțiuni ( instrucțiuni pentru subprogram și 4 instrucțiuni pentru apelul subprogramului ADMAT(...).

Dacă se încorporează toate secvențele în programul principal, acesta va arăta astfel:

................. secvență inițializare variabile M1, N1, M2, N2, M3, N3, M4, N4 .............

................. secvență inițializare matrice A, B .............

................. secvență inițializare matrice R, S .............

................. secvență inițializare matrice Y, Z .............

................. secvență inițializare matrice U, V .............

            DO 10 I=1,M1

            DO 10 J=1,N1

            C(I,J)=A(I,J)+B(I,J)

10        CONTINUE

            DO 10 I=1,M2

            DO 10 J=1,N2

            P(I,J)=R(I,J)+S(I,J)

20        CONTINUE

            DO 10 I=1,M3

            DO 10 J=1,N3

            X(I,J)=Y(I,J)+Z(I,J)

30        CONTINUE

            DO 10 I=1,M4

            DO 10 J=1,N4

            W(I,J)=U(I,J)+V(I,J)

40        CONTINUE

................. secvență cu alte prelucrări ale matricelor C, P, X și W.

Această variantă are lungime Lg = 16 instrucțiuni. Programul în prima variantă are la execuție pentru cele patru apeluri de subprograme grupul de operații complexe:

- o instrucțiune de salt necondiționat spre subprogram;

- estragere de pe stivă a adreselor operanzilor;

- execuția adunării elementelor matricelor;

- revenirea în programul apelator.

La fiecare apel volumul de prelucrări este undeva la 7 instrucțiuni, deci ceea ce părea o economie se concretizează prin 28 de instrucțiuni, dintre care unele sunt costisitoare la ciclurile mașină dacă salturile necondiționate se fac intersegment când suprogramul se află în alt segment decât programul apelator. Este o întreagă filosofie a discuta despre echilibrul lungime program și volum de prelucrări și totul se rezolvă prin măsurători de ordin statistic, adevărul fiind undeva la jumătate.

(12 ianuarie 2017)

Lungimea unui program

Lungimea unui program are diferite modalități de exprimare, numai că pentru a se obține mărimi comparabile trebuie:

- programele să fie omogene;

- stilul de programare să fie comun;

- același indicator să fie folosit peste tot.

Dacă se definesc mai mulți indicatori și se folosesc la întâmplare, rezultatele obținute nu sunt comparabile, deci nu se va trage nicio concluzie în legătura cu programele scrise și cu atât mai mult nu se vor face calcule de costuri și de productivități folosind serii de date care au termeni diferit calculați, exprimate cu unități de măsură neomogene.

Lungimea programului ca lungime de fișier se obține direct, scriid programul și stocându-l ca fișier de text sursă, exprimat în Kb sau Mb și arareori în Gb dacă este vorba de o construcție ciclopică, de invidiat și care depășește complexitatea unui sistem de operare sofisticat.

Lungimea programului ca număr total de instrucțiuni se obține direct din ceea ce oferă mediul de dezvoltare software, cu luarea în considerare a definirilor de operanzi, definirilor de proceduri, de fișiere, instrucțiunile executabile și comentariile care autodocumentează programele. Aici se numără și instrucțiunile vide. Se definește conceptul de instrucțiune, folosind separatorul de instrucțiuni, iar la numărătoare construcție e=3, f=7, g=12, x=-1, g=43; este diferită de construcția e=3; f=7; g=12; x=-1; g=43;  pentru că prima la numărătoare adaugă doar 1 căci este o expresie virgulă într-o singură instrucțiune, iar a dpua construcție intră în calcului lungimii cu 5 căci sunt 5 instrucțiuni deși sunt doar banale atribuiri, dar cresc lungimea programului, așa pricăjite cum sunt atribuirile acelea.

Lungimea programului ca număr de linii sursă se obține urmărind ceea ce numără mediul de dezvoltare, dar are un inconvenient major prin faptul că programatorul din dorința de a face lizibil programul face fragmentări cu efecte directe asuăra construcției de ansamblu.

Construcția:

for(y=s=i=0; i<n; i++) {s+=x[i]; y+=x[i]*x[i];}

are o singură linie sursă, fără ca programul să fie foarte lizibil, în timp ce construcția:

// inițializare variabile

y=0;

s=0;

// calcul sume

for(i=0; i<n; i++) 

     {

      s+=x[i]; 

      y+=x[i]*x[i];

     }

are 9 linii sursă, lungimea unui program depinzând ca număr de linii sursă de stilul de programare adoptat.

Lungimea programului ca număr de instrucțiuni executabile  se obține numărând instrucțiunile executabile și neluând în calcul definirile de variabile, de fișiere, de comentarii și de șabloane, dar și includerile de biblioteci. Unii programatori consideră că o astfel de măsurare are menirea de a evidenția efortul programatorului de a face ceva cu operanzii definți.

Ceea ce trebuie specificat este faptul că lunigimile programelor diferă de la limbaj de programare la limbaj de programare, ceea ce înseamnă că programele scrise în limbaj de asamblare conțin cu mult mai multe instrucțiuni executabile, dar instrucțiuni simple desigur, căci aceata este caracteristica limbajului de asamblare, de a conține instrucțiuni simple. Construirea  de macrodefiniții și referitea lor este o altă problemă care trebuie tratată separat, căci și refolosirea de proceduri determină scăderea lungimii programului. De aceea orice analiză de lungime trebuie să includă și studiul de repetabilitate de secvențe, fapt ce trebuie sancționat, căci reutilizarea de secvențe prin apeluri de proceduri e ochestiune de bun simț.
Lungimea unui program este o discuție fără sfârșit și cred că Brâncuși la ea s-a gândti când a făcut coloana info=initului și a instalat-o la Târgu Jiu doar pentru a trage un semnal de larmă la adrea informaticienilor.

(21 noiembrie 2017)