Assembler

Лабораторная работа №1

Тема: Метрики Холстеда

Цель работы: для заданного варианта процедуры, реализованной на языке Pascal, разработать аналогичный алгоритм и реализовать его на языках программирования С и Assembler (в ассемблерном представлении программы нужно удалить директивы описаний и отладочные директивы, оставив только исполняемые операторы); для каждой из программ определить следующие метрические характеристики (по Холстеду):

1. Измеримые характеристики программ:

Ø число простых (отдельных) операторов, в данной реализации;

Ø число простых (отдельных) операндов, в данной реализации;

Ø общее число всех операторов в данной реализации;

Ø общее число всех операндов в данной реализации;

Ø число вхождения j-го оператора в тексте программы;

Ø число вхождения j-го операнда в тексте программы;

Ø словарь программы;

Ø длина программы.

2. Расчетные характеристики программы:

Ø длина программы;

Ø реальный, потенциальный и граничный объем программы;

Ø уровень программы;

Ø интеллектуальное содержание программы;

Ø уровень используемого языка программирования.

Исходные тексты программ:

Pascal

program prog_pas;

type Tarr = array [1..8] of real;

procedure QuickSort(var x: Tarr; n: integer);

var left,right: array[1..20] of integer;

i,j,sp,mid: integer;

pivot: real;

procedure swap(var p,q: real);

var hold: real;

begin

hold:=p;

p:=q;

q:=hold

end; { swap }

begin

left[1]:=1;

right[1]:=n;

sp:=1;

while sp>0 do

begin

if left[sp]>=right[sp] then sp:=sp-1

else

begin

i:=left[sp];

j:=right[sp];

pivot:=x[j];

mid:=(i+j)div 2;

if (j-i)>5 then

if ((x[mid]<pivot)and(x[mid]>x[i])) or ((x[mid]>pivot)and(x[mid]<x[i]))

then swap(x[mid],x[j])

else

if((x[i]<x[mid])and(x[i]>pivot)) or ((x[i]>x[mid])and(x[i]<pivot))

then swap(x[i],x[j]);

pivot:=x[j];

while i<j do

begin

while x[i]<pivot do i:=i+1;

j:=j-1;

while (i<j)and(pivot<x[j]) do j:=j-1;

if i<j then swap(x[i],x[j])

end; { while }

j:=right[sp]; { pivot to i }

swap(x[i],x[j]);

if i-left[sp]>=right[sp]-i then

begin { put shorter part first }

left[sp+1]:=left[sp];

right[sp+1]:=i-1;

left[sp]:=i+1

end

else

begin

left[sp+1]:=i+1;

right[sp+1]:=right[sp];

right[sp]:=i-1

end;

sp:=sp+1 { push stack }

end { if }

end { while }

end; { QUICK SORT }

var mass: Tarr; j: integer;

begin

for j:=8 downto 1 do

begin

mass[j]:= j;

writeln (mass[j]);

end;

QuickSort(mass, 8);

writeln ('=======');

for j:=1 to 8 do writeln (mass[j]);

end.

C

// Lab1.cpp: Defines the entry point for the console application.

//

#include "stdafx.h"

#include "stdio.h"

void swap (float &p, float &q)

{

float hold;

hold = p;

p = q;

q = hold;

}

void quicksort(float x[], int n)

{

int left[20], right[20];

int i,j,sp,mid;

float pivot;

left[1] = 1;

right[1] = n;

sp = 1;

while (sp>0)

{

if (left[sp] >= right[sp])

{ sp = sp-1; }

else

{

i = left[sp];

j = right[sp];

pivot = x[j];

mid = (i+j) % 2;

if ((j-i)>5)

if (((x[mid]<pivot) && (x[mid]>x[i])) || ((x[mid]>pivot) && (x[mid]<x[i])))

swap(x[mid],x[j]);

else

if (((x[i]<x[mid]) && (x[i]>pivot)) || ((x[i]>x[mid]) && (x[i]<pivot)))

swap(x[i],x[j]);

pivot = x[j];

while (i<j)

{

while (x[i]<pivot)

{ i = i+1; }

j = j-1;

while ((i<j) && (pivot<x[j]))

{ j = j-1; }

if (i<j)

{ swap(x[i],x[j]); }

} // while

j = right[sp]; // pivot to i

swap(x[i],x[j]);

if (i-left[sp]>=right[sp]-i)

{ // put shorter part first

left[sp+1] = left[sp];

right[sp+1] = i-1;

left[sp] = i+1;

}

else

{

left[sp+1] = i+1;

right[sp+1] = right[sp];

right[sp] = i-1;

}

sp = sp+1; // push stack

} // if

} // while

}

int main()

{

float array[] = {0, 1, 3, 2, 12, 5, 9, 7, 14};

for (int k = 1; k < 9; k++)

{ printf ("%f\n", array[k]); }

printf ("================\n");

quicksort(array, 8);

for (k = 1; k < 9; k++)

{ printf ("%f\n", array[k]); }

return 0;

}

Assembler

ifndef??version

?debug macro

endm

publicdll macro name

public name

endm

endif

?debug V 300h

?debug S "LAB1.CPP"

?debug C E908AC7436084C4142312E435050

_TEXT segment byte public 'CODE'

_TEXT ends

DGROUP group _DATA,_BSS

assume cs:_TEXT,ds:DGROUP

_DATA segment word public 'DATA'

d@ label byte

d@w label word

_DATA ends

_BSS segment word public 'BSS'

b@ label byte

b@w label word

_BSS ends

_TEXT segment byte public 'CODE'

?debug C E801084C4142312E43505008AC7436

;

; void swap (float &p, float &q)

;

?debug L 10

assume cs:_TEXT

@swap$qrft1 proc near

?debug B

push bp

mov bp,sp

sub sp,4

push si

push di

?debug C E318000200340E04

?debug C E60171180A0600000170180A040000

mov si,word ptr [bp+4]

mov di,word ptr [bp+6]

?debug B

;

; {

; float hold;

; hold = p;

;

?debug L 13

fld dword ptr [si]

fstp dword ptr [bp-4]

;

; p = q;

;

?debug L 14

fld dword ptr [di]

fstp dword ptr [si]

;

; q = hold;

;

?debug L 15

fwait

mov ax,word ptr [bp-2]

mov dx,word ptr [bp-4]

mov word ptr [di+2],ax

mov word ptr [di],dx

;

;

; }

;

?debug L 17

pop di

pop si

mov sp,bp

pop bp

ret

?debug C E604686F6C640E02FCFF000170180C0600017118+

?debug C 0C0700

?debug E

?debug E

@swap$qrft1 endp

;

; void quicksort(float x[], int n)

;

?debug L 20

assume cs:_TEXT

@quicksort$qpfi proc near

?debug B

push bp

mov bp,sp

sub sp,92

push si

push di

?debug C E319000200150E04

?debug C E6016E040A0600000178190A040000

mov si,word ptr [bp+4]

?debug B

;

; {

; int left[20], right[20];

; int i,j,sp,mid;

; float pivot;

;

; left[1] = 1;

;

?debug L 26

mov word ptr [bp-50],1

;

; right[1] = n;

;

?debug L 27

mov ax,word ptr [bp+6]

mov word ptr [bp-90],ax

;

; sp = 1;

;

?debug L 28

mov word ptr [bp-4],1

jmp @2@898

@2@58:

;

;

; while (sp>0)

; {

; if (left[sp] >= right[sp])

;

?debug L 32

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-52]

add bx,ax

mov ax,word ptr [bx]

mov bx,word ptr [bp-4]

shl bx,1

lea dx,word ptr [bp-92]

add bx,dx

cmp ax,word ptr [bx]

jl short @2@114

;

; { sp = sp-1; }

;

?debug L 33

mov ax,word ptr [bp-4]

dec ax

jmp @2@870

@2@114:

;

; else

; {

; i = left[sp];

;

?debug L 36

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-52]

add bx,ax

mov di,word ptr [bx]

;

; j = right[sp];

;

?debug L 37

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-92]

add bx,ax

mov ax,word ptr [bx]

mov word ptr [bp-2],ax

;

; pivot = x[j];

;

?debug L 38

mov bx,word ptr [bp-2]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fstp dword ptr [bp-10]

;

; mid = (i+j) % 2;

;

?debug L 39

mov ax,di

fwait

add ax,word ptr [bp-2]

mov bx,2

cwd

idiv bx

mov word ptr [bp-6],dx

;

; if ((j-i)>5)

;

?debug L 40

mov ax,word ptr [bp-2]

sub ax,di

cmp ax,5

jg @@2

jmp @2@422

@@2:

;

; if (((x[mid]<pivot) && (x[mid]>x[i])) || ((x[mid]>pivot) && (x[mid]<x[i])))

;

?debug L 41

mov bx,word ptr [bp-6]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fcomp dword ptr [bp-10]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jae short @2@198

mov bx,word ptr [bp-6]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

mov bx,di

mov cl,2

shl bx,cl

fcomp dword ptr [bx+si]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

ja short @2@254

@2@198:

mov bx,word ptr [bp-6]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fcomp dword ptr [bp-10]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jbe short @2@282

mov bx,word ptr [bp-6]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

mov bx,di

mov cl,2

shl bx,cl

fcomp dword ptr [bx+si]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jae short @2@282

@2@254:

;

; swap(x[mid],x[j]);

;

?debug L 42

mov ax,word ptr [bp-2]

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

mov ax,word ptr [bp-6]

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

call near ptr @swap$qrft1

pop cx

pop cx

jmp @2@422

@2@282:

;

; else

; if (((x[i]<x[mid]) && (x[i]>pivot)) || ((x[i]>x[mid]) && (x[i]<pivot)))

;

?debug L 44

mov bx,di

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

mov bx,word ptr [bp-6]

mov cl,2

shl bx,cl

fcomp dword ptr [bx+si]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jae short @2@338

mov bx,di

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fcomp dword ptr [bp-10]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

ja short @2@394

@2@338:

mov bx,di

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

mov bx,word ptr [bp-6]

mov cl,2

shl bx,cl

fcomp dword ptr [bx+si]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jbe short @2@422

mov bx,di

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fcomp dword ptr [bp-10]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jae short @2@422

@2@394:

;

; swap(x[i],x[j]);

;

?debug L 45

mov ax,word ptr [bp-2]

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

mov ax,di

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

call near ptr @swap$qrft1

pop cx

pop cx

@2@422:

;

; pivot = x[j];

;

?debug L 46

mov bx,word ptr [bp-2]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fstp dword ptr [bp-10]

fwait

jmp short @2@702

@2@450:

jmp short @2@506

@2@478:

;

; while (i<j)

; {

; while (x[i]<pivot)

; { i = i+1; }

;

?debug L 50

mov ax,di

inc ax

mov di,ax

@2@506:

?debug L 49

mov bx,di

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fcomp dword ptr [bp-10]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

jb short @2@478

jmp short @2@562

@2@562:

;

; j = j-1;

; while ((i<j) && (pivot<x[j]))

; { j = j-1; }

;

?debug L 53

mov ax,word ptr [bp-2]

dec ax

mov word ptr [bp-2],ax

?debug L 52

cmp di,word ptr [bp-2]

jge short @2@646

mov bx,word ptr [bp-2]

mov cl,2

shl bx,cl

fld dword ptr [bx+si]

fcomp dword ptr [bp-10]

fstsw word ptr [bp-12]

fwait

mov ax,word ptr [bp-12]

sahf

ja short @2@562

@2@646:

;

; if (i<j)

;

?debug L 54

cmp di,word ptr [bp-2]

jge short @2@702

;

; { swap(x[i],x[j]); }

;

?debug L 55

mov ax,word ptr [bp-2]

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

mov ax,di

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

call near ptr @swap$qrft1

pop cx

pop cx

@2@702:

?debug L 47

cmp di,word ptr [bp-2]

jl short @2@450

;

; } // while

; j = right[sp]; // pivot to i

;

?debug L 57

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-92]

add bx,ax

mov ax,word ptr [bx]

mov word ptr [bp-2],ax

;

; swap(x[i],x[j]);

;

?debug L 58

mov ax,word ptr [bp-2]

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

mov ax,di

mov cl,2

shl ax,cl

mov dx,si

add dx,ax

push dx

call near ptr @swap$qrft1

pop cx

pop cx

;

; if (i-left[sp]>=right[sp]-i)

;

?debug L 59

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-52]

add bx,ax

mov ax,di

sub ax,word ptr [bx]

mov bx,word ptr [bp-4]

shl bx,1

lea dx,word ptr [bp-92]

add bx,dx

mov dx,word ptr [bx]

sub dx,di

cmp ax,dx

jl short @2@786

;

; { // put shorter part first

; left[sp+1] = left[sp];

;

?debug L 61

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-52]

add bx,ax

mov ax,word ptr [bx]

mov bx,word ptr [bp-4]

shl bx,1

lea dx,word ptr [bp-50]

add bx,dx

mov word ptr [bx],ax

;

; right[sp+1] = i-1;

;

?debug L 62

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-90]

add bx,ax

mov ax,di

dec ax

mov word ptr [bx],ax

;

; left[sp] = i+1;

;

?debug L 63

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-52]

add bx,ax

mov ax,di

inc ax

jmp short @2@814

@2@786:

;

; }

; else

; {

; left[sp+1] = i+1;

;

?debug L 67

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-50]

add bx,ax

mov ax,di

inc ax

mov word ptr [bx],ax

;

; right[sp+1] = right[sp];

;

?debug L 68

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-92]

add bx,ax

mov ax,word ptr [bx]

mov bx,word ptr [bp-4]

shl bx,1

lea dx,word ptr [bp-90]

add bx,dx

mov word ptr [bx],ax

;

; right[sp] = i-1;

;

?debug L 69

mov bx,word ptr [bp-4]

shl bx,1

lea ax,word ptr [bp-92]

add bx,ax

mov ax,di

dec ax

@2@814:

mov word ptr [bx],ax

;

; }

; sp = sp+1; // push stack

;

?debug L 71

mov ax,word ptr [bp-4]

inc ax

@2@870:

mov word ptr [bp-4],ax

@2@898:

?debug L 30

cmp word ptr [bp-4],0

jle @@3

jmp @2@58

@@3:

;

; } // if

; } // while

;

;

; }

;

?debug L 76

pop di

pop si

mov sp,bp

pop bp

ret

?debug C E31A0028001A04

?debug C E31B0028001A04

?debug C E6057069766F740E02F6FF00036D69640402FAFF+

?debug C 000273700402FCFF00016A0402FEFF0001690404+

?debug C 07000572696768741A02A4FF00046C6566741B02+

?debug C CCFF000178190C0600016E040A060000

?debug E

?debug E

@quicksort$qpfi endp

_TEXT ends

_DATA segment word public 'DATA'

db 0

db 0

db 0

db 0

db 0

db 0

db 128

db 63

db 0

db 0

db 64

db 64

db 0

db 0

db 0

db 64

db 0

db 0

db 64

db 65

db 0

db 0

db 160

db 64

db 0

db 0

db 16

db 65

db 0

db 0

db 224

db 64

db 0

db 0

db 96

db 65

_DATA ends

_TEXT segment byte public 'CODE'

;

; int main()

;

?debug L 80

assume cs:_TEXT

_main proc near

?debug B

push bp

mov bp,sp

sub sp,36

?debug B

;

; {

; float array[] = {0, 1, 3, 2, 12, 5, 9, 7, 14};

;

?debug L 82

lea ax,word ptr [bp-36]

push ss

push ax

mov ax,offset DGROUP:d@w+0

push ds

push ax

mov cx,36

call near ptr N_SCOPY@

;

;

; quicksort(array, 8);

;

?debug L 84

mov ax,8

push ax

lea ax,word ptr [bp-36]

push ax

call near ptr @quicksort$qpfi

pop cx

pop cx

;

;

; return 0;

;

?debug L 86

xor ax,ax

jmp short @3@58

@3@58:

;

; }

;

?debug L 87

mov sp,bp

pop bp

ret

?debug C E31C0024001A0E

?debug C E60561727261791C02DCFF00

?debug E

?debug E

_main endp

?debug C E9

?debug C FA00000000

_TEXT ends

_DATA segment word public 'DATA'

s@ label byte

_DATA ends

_TEXT segment byte public 'CODE'

_TEXT ends

extrn __turboFloat:word

extrn N_SCOPY@:far

public _main

public @quicksort$qpfi

public @swap$qrft1

_s@ equ s@

?debug C EA0509

?debug C E31D00000023040500

?debug C EB084E5F53434F5059401D00

?debug C E31E00000023040000

?debug C EC055F6D61696E1E1800

?debug C E31F00000023010000

?debug C EC0F40717569636B736F727424717066691F1800

?debug C E32000000023010000

?debug C EC0B4073776170247172667431201800

end