二、Ｃ

    Ｃ近来极受美国各系统公司的推崇，我们特以之与组合语言作个比较，但不幸的是在指令的精简上，就显得力不从心，不像组合语言那样可以斤斤计较。
    因此，我们祇能就点阵移位、查小表及查总表的方式，测试其效率。首先，利用查大表的方式如下：

  1: main()
  2: {
  3:     unsigned char     s[24][3];
  4:     unsigned short  tab[256], d[48][3], count;
  5:     reGISter short  i,j,k;
  6:
  7:     for (count = 0; count < 10000; count++)
  8:     {
  9:         k = 0;
 10:         for (i = 0; i < 24; i++)
 11:         {
 12:         for (j = 0; j < 3; j++)
 13:            d[k][j] = d[k + 1][j] = tab[s[i][j]];
 14:         k += 2;
 15:         }
 16:     }
 17: }

    程式制作时间10分钟，较组合语言稍快；占用空间4575字元，则大了三倍，至于执行速度为18秒，慢了七倍之多。
    再换个方法，试一试查小表如次：
  1: main()
  2: {
  3:     unsigned char    i,j, s[24][3], d[48][6], tab[16];
  4:     unsigned short  count;
  5:     register short  k, l, x;
  6:
  7:     for (count = 0; count < 10000; count++)
  8:     {
  9:         k = 0;
 10:         for (i = 0; i < 24; i++)
 11:         {
 12:         l = 0;
 13         for (j = 0; j < 3; j++)
 14:         {
 15:             x = s[i][j];
 16:          d[k][l] = d[k + 1][l] = tab[x & 0360 >> 4];
 17:          d[k][l+1] = d[k + 1][l + 1] = tab[x & 017];
 18:             l += 2;
 19:         }
 20:         k += 2;
 21:         }
 22:     }
 23: }
    占用空间为4,693 字元，比组合语言大了五倍；速度为30秒，则慢了四倍多。这证明了组合语言的灵活性，在空时效率交换的技术运用下，可以选择最有利的条件。再看利用位置的方式，结果如何？

  1: main()
  2: {
  3:     unsigned char          ss[24][3];
  4:     unsigned short       dd[48][3];
  5:     int              i, k, count;
  6:     register short       d, j;
  7:     register unsigned char   s;
  8:
  9:     for (count = 0; count < 10000; count++)
 10:     {
 11:         k = 0;
 12:         for (i = 0; i < 24; i++)
 13:         {
 14:         for (j = 0; j < 3; j++)
 15:         {
 16:             s = ss[i][j];
 17:             d = 0;
 18:             if (s & 01)
 19:             d |= 03;
 20:             if (s & 02)
 21:             d |= 014;
 22:             if (s & 04)
 23:             d |= 060;
 24:             if (s & 010)
 25:             d |= 0300;
 26:             if (s & 020)
 27:             d |= 01400;
 28:             if (s & 040)
 29:             d |= 06000;
 30:             if (s & 0100)
 31:             d |= 030000;
 32:             if (s & 0200)
 33:             d |= 0140000;
 34:             dd[k + 1][j] = dd[k][j] = d;
 35:         }
 36:         k += 2;
 37:         }
 38:     }
 39:}

    占用的空间为 4,727字元，较组合语言大四倍，执行时间29秒，差不多是四倍的差异。这种采用高阶指令的方式，拉近了Ｃ与组合语言的距离。足证纵然使用组合语言，若不采用精简指令的技巧，其效率不彰。一般程式师很少在组合语言的技巧上下功夫, 以致不能认识组合语言的真面目。

三、BASIC

 10: DIM wd24(23,2),WD48(47,5),table(255),mask(7)
 20: r1=0
 30: r2=0
 40: REM  用测试点的方式，每字元分八次处理。
 50: mask(0)=0
 60: mask(1)=2
 70: FOR i=2 TO 7
 80: mask(i)=mask(i-1)*2
 90: NEXT i
100: INPUT A$
110: FOR count=1 TO 10
120: K=0
130: FOR i=O TO 23
140: T=0
150: FOR j=0 TO 2
160: FOR m=0 TO 7
170: temp=table(wd24(i,j))
180: temp=temp AND mask(m)
190: IF temp=128 THEN r1=192 AND r1
200: IF temp=64 THEN r1=48 AND r1
210: IF temp=32 THEN r1=12 AND r1
220: IF temp=16 THEN r1=3 AND r1
230: IF temp=8 THEN r2=192 AND r2
240: IF temp=128 THEN r2=48 AND r2
250: IF temp=64 THEN r2=12 AND r2
260: IF temp=32 THEN r2=3 AND r2
270: NEXT m
280: wd48(K,T)=r1
290: wd48(K,T+1)=r2
300: wd48(K+1,T)=r1
310: wd48(K+1,T+1)=r2
320: T=T+2
330: NEXT j
340: K=K+2
350: NEXT i
360: NEXT count
370: PRINT "FINISHED"
380: END

    本程式制作时间为10分钟，执行程式共占12,764字元，执行时间为23,000秒！
    足证BASIC 不适用于点阵处理，由于上述的处理方法是以移位为主，因BASIC 没有专用的指令，所以非常不利。现在改用查表方法，再看如何。

 10: REM  本程式将24*2４的点阵以查表方式转为48*48
 20: rem  本程式用quickbasic version 4.00 microsoft inc.
 30: dim wd24(23,2),wd48(47,2).table(255)
 40:     FOR K=1 TO 100
 50:         T=0
 60:         FOR I=0 TO 23
 70:         FOR J=0 TO 2
 80:             A=TABLE(WD24(I,J))
 90:             WD48(T,J)=A
100:             WD48(T+1,J)=A
110:         NEXT J
120:         NEXT I
130:     NEXT K
140: END

    本程式所用对照表与一、同，执行程式占11,642字元，执行时间共计1,800 秒。
    其他的改进方法当然还有，可是看来已接近极限。

四、PASCAL

    PASCAL仅适用于查总表的方式，在我们没有发展出「制表法」以前，几乎要放弃这个试验。现在，且沿用组合语言所用的总表，看其效率如何吧！

  1: PROGRAM PASTABLE;
  2: VAR
  3:     SOURCE :PACKED ARRAY[1…24,1…3] OF -128…127;
  4:     OBJCT    :ARRAY[1…48,1…3] OF INTEGER;
  5:     TABLE    :ARRAY[0…255] OF INTEGER;
  6:     I,J,K,N:INTEGER;
  7: BEGIN
  8:     FOR N:=1 TO 10000 DO
  9:     BEGIN
 10:         K:=O;
 11:         FOR I:=1 TO 24 DO
 12:         BEGIN
 13:         FOR J:=1 TO 3 DO
 14:         BEGIN
 15:             OBJCT[K,J]=TABLE[SOURCE[I,J];
 16:             OBJCT[K+1,J]=OBJCT[K,J]
 17:         END;
 18:         K:=K+2
 19:         END
 20:     END
 21: end.

    本程式制作需时10分钟，空间占11,650字元，执行时间为17秒，较BASIC 为佳。
    显然 PASCAL 的效率较Ｃ及组合语言为差，但若不计总表，程式仅21条，差强人意。

五、FORTRAN

    同样的，FORTRAN 也祇能用查表的方法，程式如下：

  1: DIMENSION IT1(24,3(,IT2(48,6),IT3(256)
  2: DO 40 II=1,10000
  3: DO 30 I=1,24
  4: M=I+I
  5: DO 30 J=1,3
  6: K=IT3(IT1(I,J))
  7: IT2(M-1,J)=K
  8: 30 IT2(M,J)=K
  9: 40 CONTINUE
 10: END
    这段程式也是用查表的方式，制作时间７分钟，执行程式 9,959字元，比Ｃ稍大，执行速度也较慢，为20秒。另外，在 FORTRAN中也没有找到适合的位元控制指令，因此很难再加改进。
    从上述的试验中，可以看出这几种语言的效率差异。不论用什么方法，组合语言明显地遥遥领先。
    就制作时间而言，因为程式简单，看不出很大分别。事实上，组合语言的确比较复杂，祇是我们习惯成自然，有了经验，所以制作时显得轻松。
    以下为上述测试的统计表：
 ┌────┬────┬────┬──────┬─────┬──────┐
 │处理方式│程式语言│制作时间│  程式空间  │执行速度 │  备    注  │
 │        │        │（分钟）│  （字元）  │ （秒）  │            │
 ├────┼────┼────┼──────┼─────┼──────┤
 │点阵位移│组合语言│   15   │      970   │      7.1 │            │
 │        │c       │   10   │    4,727   │     29.0 │            │
 │        │basic?│   10   │   12,764   │ 23,000.0 │            │
 ├────┼────┼────┼──────┼─────┼──────┤
 │查小表法│组合语言│   15   │      949   │      3.2 │边际效益最高│
 │        │c       │   10   │    4,693   │     30.0 │            │
 ├────┼────┼────┼──────┼─────┼──────┤
 │查总表法│组合语言│   15   │    1,441   │      2.5 │速度效益最高│
 │        │c       │   10   │    4,575   │     18.0 │            │
 │        │pascal  │   10   │   11,650   │     17.0 │            │
 │        │fortrcn │?7   │    9,959   │     20.0 │            │
 │        │basic     │   10   │   11,692   │  1,800.0 │            │
 └────┴────┴────┴──────┴─────┴──────┘

上一篇： 汇编语言---套装软件制作（1）
下一篇： 如何建立汇编工作环境