Some Data about Speed of Multiplication and Addition - Chen Li

Some Data about Speed of Multiplication and Addition

1. Running 34,359,738,367 (0x7ffffffff) times

program	real time	user	system	instruction retired	cycles elapsed
mul	10.80	10.77	0.03	206,174,586,404	34,460,405,906
add	10.81	10.77	0.02	206,174,961,103	34,452,388,733
add	10.80	10.76	0.03	206,174,196,589	34,463,690,145
mul	10.81	10.77	0.03	206,174,331,889	34,466,289,391

2. Running 137,438,953,471 (0x1fffffffff) times

program	real time	user	system	instruction retired	cycles elapsed
add	43.12	42.98	0.12	824,684,047,224	137,845,540,756
mul	43.26	43.05	0.19	824,706,262,533	138,088,583,489
mul	43.11	42.99	0.09	824,678,165,222	137,763,496,059
add	43.11	42.99	0.10	824,680,759,525	137,775,698,560

3. Code

add.s

.include "debug.s"
.global main
.p2align 2

main:
        mov     w1,     #1
        mov     w2,     #2
        mov     w4,     w1
        mov     w5,     w2
        mov     x3,     #0xffff
        movk    x3,     #0xffff,    lsl #16
        movk    x3,     #0x0007,    lsl #32
        movk    x3,     #0x0000,    lsl #48
loop:   subs    x3,     x3,     #1
        b.eq    print
        add     w1,     w1,     w2
        mov     w1,     w4
        mov     w2,     w5
        b       loop
print:  printReg    1

				// return 0
        mov     x0,     #0
        ret

mul.s

.include "debug.s"
.global main
.p2align 2

main:
        mov     w1,     #1
        mov     w2,     #2
        mov     w4,     w1
        mov     w5,     w2
        mov     x3,     #0xffff
        movk    x3,     #0xffff,    lsl #16
        movk    x3,     #0x0007,    lsl #32
        movk    x3,     #0x0000,    lsl #48
loop:   subs    x3,     x3,     #1
        b.eq    print
        smull   x1,     w1,     w2
        mov     w1,     w4
        mov     w2,     w5
        b       loop
print:  printReg    1

				// return 0
        mov     x0,     #0
        ret

Same points in these two programs

• Same registers
  • w1, w2: operation register;
  • x1: destination register;
  • x3: index register;
  • x0: kernel parameter;
• Same statements
  • w1 = 1, w2 = 2;
  • w4 = w1, w5 = w2;
  • same loop logic;
  • w1 and w2 are assigned by their initial value;
  • same printReg:
    • store x0-x18 and lr (general registers) to stack;
    • put the parameters from x0 to x3;
    • put x1-x3 to stack;
    • invoke _printf;
    • load x0-x18 and lr (general registers) from stack;
  • return 0;

The only difference between these two programs is add and smull.

4. First Conclusion

These two given tables illustrate the performance difference between multiplication and addition instructions for integers arithmetic. Overall, it proves that addition instructions execute faster tha multiplication instructions for integers.

Firstly take a look at the first table. This table sorted those records by time and these two programs compiled just once. Time usage of these executions are very near. The total time is about 10.80s and system time is 0.03s approximately. However, add can be completed by 10.76s at least, which is 0.01s faster than mul can. As for instruction retired, mul has 206,174,586,404 retired instructions, which is above 400,000 less than add has. If they execute again, they both can get about 400,000 retired instructions decrease. They both have similar cycle elapsed in their two executions. mul needs more cycles than add in order to complete its task.

Regarding the second tables, time, instruction retired and cycle elapsed all have a very huge growth because the loop round number is much larger. The total time in four recordings is about 43s and system time is 0.10s approximately. In first round(i.e. the first two records), add needs 42.98s to run, which is 0.07s less than mul needs. With the optimisation of system, they can have the same performance, 42.99s. They need 840 billions retired instruction and about 137 cycles to finish the task.

All in all, with the improvement made by processor, mul and add can have a similar performance. But at first time, add performs better without any optimisation. Thus we can get the conclusion that addition instructions execute faster than multiplications.

5. Code Improve

I learn that C programming language provides efficient library to measure the clock and time used in the program. Therefore I update the code in order to get rid of the time command. All in all, using in-code method to measure the clock and time used is more accuracy and elegant than using time command provided by UNIX. Here are the two updated codes.

add.s

.include "debug.s"
.global main
.p2align 2

main:
        mov     w1,     #1
        mov     w2,     #2
        mov     w4,     w1
        mov     w5,     w2
        mov     x3,     #0xffff
        movk    x3,     #0xffff,    lsl #16
        movk    x3,     #0x0007,    lsl #32
        movk    x3,     #0x0000,    lsl #48

        // start clock
        stp     fp,     lr,     [sp, #-16]!
        bl      _clock
        ldp     fp,     lr,     [sp],   #16
        mov     x8,     x0
        str     x8,     [sp, #-16]!

        // do add for x3-1 times
loop:   subs    x3,     x3,     #1
        b.eq    after
        add     w1,     w1,     w2
        mov     w1,     w4
        mov     w2,     w5
        b       loop

        // end clock
after:  stp     fp,     lr,     [sp, #-16]!
        bl      _clock
        ldp     fp,     lr,     [sp],   #16
        mov     x9,     x0
        str     x9,     [sp, #8]

        // calculate
        mov     x10,    #0x4240
        movk    x10,    #0xf,   lsl #16
        ldp     x8,     x9,     [sp]
        ldr     x7,     [sp]
        scvtf   d8,     x8
        scvtf   d9,     x9
        scvtf   d10,    x10
        fsub    d8,     d9,     d8
        fdiv    d8,     d8,     d10
        fmov    x8,     d8

        // results
        printStr        "Add instructions speed test"
        printStr        "Start Clock:"
        printReg        7
        printStr        "End Clock:"
        printReg        9
        printStr        "Time used:"
        printDouble     8
        printStr        ""
        

		// return 0
        mov     x0,     #0
        ret

mul.s

.include "debug.s"
.global main
.p2align 2

main:
        mov     w1,     #1
        mov     w2,     #2
        mov     w4,     w1
        mov     w5,     w2
        mov     x3,     #0xffff
        movk    x3,     #0xffff,    lsl #16
        movk    x3,     #0x0007,    lsl #32
        movk    x3,     #0x0000,    lsl #48

        // start clock
        stp     fp,     lr,     [sp, #-16]!
        bl      _clock
        ldp     fp,     lr,     [sp],   #16
        mov     x8,     x0
        str     x8,     [sp, #-16]!

        // do add for x3-1 times
loop:   subs    x3,     x3,     #1
        b.eq    after
        smull   x1,     w1,     w2
        mov     w1,     w4
        mov     w2,     w5
        b       loop

        // end clock
after:  stp     fp,     lr,     [sp, #-16]!
        bl      _clock
        ldp     fp,     lr,     [sp],   #16
        mov     x9,     x0
        str     x9,     [sp, #8]

        // calculate
        mov     x10,    #0x4240
        movk    x10,    #0xf,   lsl #16
        ldp     x8,     x9,     [sp]
        ldr     x7,     [sp]
        scvtf   d8,     x8
        scvtf   d9,     x9
        scvtf   d10,    x10
        fsub    d8,     d9,     d8
        fdiv    d8,     d8,     d10
        fmov    x8,     d8

        // results
        printStr        "Mul instructions speed test"
        printStr        "Start Clock:"
        printReg        7
        printStr        "End Clock:"
        printReg        9
        printStr        "Time used:"
        printDouble     8
        printStr        ""
        

		// return 0
        mov     x0,     #0
        ret