ARM aarch64 assembly learning notes (IX): Using Neon instructions (I)

NEON is an ARM technology based on the SIMD concept. SIMD, Single Instruction Multiple Data, is a parallel processing technology that uses a single instruction to process multiple data. Compared with one instruction processing one data, the computing speed will be greatly improved.

ARMv8 has 31 64-bit registers and 1 special register with different names, the purpose depends on the context, so we can think of it as 31 64-bit X registers or 31 32-bit W registers (the lower 32 bits of the X register)

ARMv8 has 32 128-bit V registers. Similarly, we can also think of them as 32 32-bit S registers or 32 64-bit D registers.

It can also be used as 32 64bit D0-D31 or 32 32bit S0-S31 or 32 16bit H0-h31 or 32 8bit B0-B31.

Let’s take a simple example to illustrate the benefits of using Neon.

For example, there is a very simple requirement. There are 2 sets of data, each set of data has 16 x 1024 integers. Let them be added one by one in order to get the sum (the number of each set of data does not exceed 255, and if the sum is greater than 255, 255 is returned).

If implemented in C language:

#include

#include

#define MAX_LEN 16 * 1024 * 1024

typedef unsigned char uint_8t;

typedef unsigned short uint_16t;

int main()

{

double start_time;

double end_time;

uint_8t *dist1 = (uint_8t *)malloc(sizeof(uint_8t) * MAX_LEN);

uint_8t *dist2 = (uint_8t *)malloc(sizeof(uint_8t) * MAX_LEN);

uint_16t *ref_out = (uint_16t *)malloc(sizeof(uint_16t) * MAX_LEN);

// 2 sets of data are randomly assigned

for (int i = 0; i < MAX_LEN; i++)

{

dist1[i] = rand() % 256;

dist2[i] = rand() % 256;

}

start_time = clock();

for (int i = 0; i < MAX_LEN; i++)

{

ref_out[i] = dist1[i] + dist2[i];

if (ref_out[i] > 255)

{

ref_out[i] = 255;

}

}

end_time = clock();

printf("C use time %f sn", end_time - start_time);

return 0;

}

Because the C language implementation only operates one register for each addition, and since each input and output is no greater than 255, it can be stored in an 8-bit register, which causes a waste of registers.

If using Neon for acceleration:

.text

.global asm_add_neon

asm_add_neon:

LOOP:

LDR Q0, [X0], #0x10

LDR Q1, [X1], #0x10

UQADD V0.16B, V0.16B, V1.16B

STR Q0, [X2], #0x10

SUBS X3, X3, #0x10

B.NE LOOP

RIGHT

Q0 represents array A, Q1 represents array B, 128 bits (16) are read each time, and the ARM vector non-saturated addition instruction UQADD is used for calculation, and the result is stored in the X2 register.

Compare the performance of C language and ARM NEON acceleration:

#include

#include

#define MAX_LEN 16 * 1024 * 1024

typedef unsigned char uint_8t;

typedef unsigned short uint_16t;

extern int asm_add_neon(uint_8t *dist1, uint_8t *dist2, uint_8t *out, int len);

int main()

{

double start_time;

double end_time;

uint_8t *dist1 = (uint_8t *)malloc(sizeof(uint_8t) * MAX_LEN);

uint_8t *dist2 = (uint_8t *)malloc(sizeof(uint_8t) * MAX_LEN);

uint_8t *out = (uint_8t *)malloc(sizeof(uint_8t) * MAX_LEN);

uint_16t *ref_out = (uint_16t *)malloc(sizeof(uint_16t) * MAX_LEN);

for (int i = 0; i < MAX_LEN; i++)

{

dist1[i] = rand() % 256;

dist2[i] = rand() % 256;

}

start_time = clock();

for (int i = 0; i < MAX_LEN; i++)

{

ref_out[i] = dist1[i] + dist2[i];

if (ref_out[i] > 255)

{

ref_out[i] = 255;

}

//printf("%d dist1[%d] dist2[%d] refout[%d] n", i,dist1[i], dist2[i],  ref_out[i]);

}

end_time = clock();

printf("C use time %f sn", end_time - start_time);

start_time = clock();

asm_add_neon(dist1, dist2, out, MAX_LEN);

end_time = clock();

printf("asm use time %f sn", end_time - start_time);

for (int i = 0; i < MAX_LEN; i++)

{

if (out[i] != ref_out[i])

{

printf("ERROR:%dn", i);

return -1;

}

}

printf("PASS!n");

return 0;

}

The performance of the arm neon assembly implementation is exactly about 16 times that of the pure C language implementation.