diff options
Diffstat (limited to 'libgfortran/generated')
| -rw-r--r-- | libgfortran/generated/matmul_c10.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_c16.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_c4.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_c8.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_i16.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_i4.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_i8.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_r10.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_r16.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_r4.c | 71 | ||||
| -rw-r--r-- | libgfortran/generated/matmul_r8.c | 71 |
11 files changed, 693 insertions, 88 deletions
diff --git a/libgfortran/generated/matmul_c10.c b/libgfortran/generated/matmul_c10.c index 44e734f0863..edbd1e6becc 100644 --- a/libgfortran/generated/matmul_c10.c +++ b/libgfortran/generated/matmul_c10.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_COMPLEX_10) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_c10 (gfc_array_c10 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_c10 (gfc_array_c10 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_COMPLEX_10 *restrict abase_x; + const GFC_COMPLEX_10 *restrict bbase_y; + GFC_COMPLEX_10 *restrict dest_y; + GFC_COMPLEX_10 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_10) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_c10 (gfc_array_c10 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_COMPLEX_10 *restrict abase_x; + const GFC_COMPLEX_10 *restrict bbase_y; + GFC_COMPLEX_10 *restrict dest_y; + GFC_COMPLEX_10 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_10) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_c16.c b/libgfortran/generated/matmul_c16.c index 451ea82f6e8..c04146be821 100644 --- a/libgfortran/generated/matmul_c16.c +++ b/libgfortran/generated/matmul_c16.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_COMPLEX_16) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_c16 (gfc_array_c16 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_c16 (gfc_array_c16 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_COMPLEX_16 *restrict abase_x; + const GFC_COMPLEX_16 *restrict bbase_y; + GFC_COMPLEX_16 *restrict dest_y; + GFC_COMPLEX_16 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_16) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_c16 (gfc_array_c16 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_COMPLEX_16 *restrict abase_x; + const GFC_COMPLEX_16 *restrict bbase_y; + GFC_COMPLEX_16 *restrict dest_y; + GFC_COMPLEX_16 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_16) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_c4.c b/libgfortran/generated/matmul_c4.c index 5e59f1dafdc..a01de37bc74 100644 --- a/libgfortran/generated/matmul_c4.c +++ b/libgfortran/generated/matmul_c4.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_COMPLEX_4) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_c4 (gfc_array_c4 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_c4 (gfc_array_c4 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_COMPLEX_4 *restrict abase_x; + const GFC_COMPLEX_4 *restrict bbase_y; + GFC_COMPLEX_4 *restrict dest_y; + GFC_COMPLEX_4 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_4) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_c4 (gfc_array_c4 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_COMPLEX_4 *restrict abase_x; + const GFC_COMPLEX_4 *restrict bbase_y; + GFC_COMPLEX_4 *restrict dest_y; + GFC_COMPLEX_4 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_4) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_c8.c b/libgfortran/generated/matmul_c8.c index cdf10e20461..75ec4fc101c 100644 --- a/libgfortran/generated/matmul_c8.c +++ b/libgfortran/generated/matmul_c8.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_COMPLEX_8) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_c8 (gfc_array_c8 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_c8 (gfc_array_c8 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_COMPLEX_8 *restrict abase_x; + const GFC_COMPLEX_8 *restrict bbase_y; + GFC_COMPLEX_8 *restrict dest_y; + GFC_COMPLEX_8 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_8) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_c8 (gfc_array_c8 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_COMPLEX_8 *restrict abase_x; + const GFC_COMPLEX_8 *restrict bbase_y; + GFC_COMPLEX_8 *restrict dest_y; + GFC_COMPLEX_8 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_COMPLEX_8) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_i16.c b/libgfortran/generated/matmul_i16.c index a5a40b487f9..eacc47ff8cd 100644 --- a/libgfortran/generated/matmul_i16.c +++ b/libgfortran/generated/matmul_i16.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_INTEGER_16) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_i16 (gfc_array_i16 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_i16 (gfc_array_i16 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_INTEGER_16 *restrict abase_x; + const GFC_INTEGER_16 *restrict bbase_y; + GFC_INTEGER_16 *restrict dest_y; + GFC_INTEGER_16 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_INTEGER_16) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_i16 (gfc_array_i16 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_INTEGER_16 *restrict abase_x; + const GFC_INTEGER_16 *restrict bbase_y; + GFC_INTEGER_16 *restrict dest_y; + GFC_INTEGER_16 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_INTEGER_16) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_i4.c b/libgfortran/generated/matmul_i4.c index dca23987e71..6166bf18c29 100644 --- a/libgfortran/generated/matmul_i4.c +++ b/libgfortran/generated/matmul_i4.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_INTEGER_4) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_i4 (gfc_array_i4 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_i4 (gfc_array_i4 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_INTEGER_4 *restrict abase_x; + const GFC_INTEGER_4 *restrict bbase_y; + GFC_INTEGER_4 *restrict dest_y; + GFC_INTEGER_4 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_INTEGER_4) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_i4 (gfc_array_i4 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_INTEGER_4 *restrict abase_x; + const GFC_INTEGER_4 *restrict bbase_y; + GFC_INTEGER_4 *restrict dest_y; + GFC_INTEGER_4 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_INTEGER_4) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_i8.c b/libgfortran/generated/matmul_i8.c index ceadbe3c801..b83ded04ebf 100644 --- a/libgfortran/generated/matmul_i8.c +++ b/libgfortran/generated/matmul_i8.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_INTEGER_8) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_i8 (gfc_array_i8 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_i8 (gfc_array_i8 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_INTEGER_8 *restrict abase_x; + const GFC_INTEGER_8 *restrict bbase_y; + GFC_INTEGER_8 *restrict dest_y; + GFC_INTEGER_8 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_INTEGER_8) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_i8 (gfc_array_i8 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_INTEGER_8 *restrict abase_x; + const GFC_INTEGER_8 *restrict bbase_y; + GFC_INTEGER_8 *restrict dest_y; + GFC_INTEGER_8 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_INTEGER_8) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_r10.c b/libgfortran/generated/matmul_r10.c index b0ebbeda6c4..6702209bd22 100644 --- a/libgfortran/generated/matmul_r10.c +++ b/libgfortran/generated/matmul_r10.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_REAL_10) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_r10 (gfc_array_r10 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_r10 (gfc_array_r10 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_REAL_10 *restrict abase_x; + const GFC_REAL_10 *restrict bbase_y; + GFC_REAL_10 *restrict dest_y; + GFC_REAL_10 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_10) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_r10 (gfc_array_r10 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_REAL_10 *restrict abase_x; + const GFC_REAL_10 *restrict bbase_y; + GFC_REAL_10 *restrict dest_y; + GFC_REAL_10 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_10) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_r16.c b/libgfortran/generated/matmul_r16.c index 313f8d2d6d8..c095cbdb747 100644 --- a/libgfortran/generated/matmul_r16.c +++ b/libgfortran/generated/matmul_r16.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_REAL_16) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_r16 (gfc_array_r16 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_r16 (gfc_array_r16 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_REAL_16 *restrict abase_x; + const GFC_REAL_16 *restrict bbase_y; + GFC_REAL_16 *restrict dest_y; + GFC_REAL_16 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_16) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_r16 (gfc_array_r16 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_REAL_16 *restrict abase_x; + const GFC_REAL_16 *restrict bbase_y; + GFC_REAL_16 *restrict dest_y; + GFC_REAL_16 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_16) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_r4.c b/libgfortran/generated/matmul_r4.c index 74a4e1c23b9..dedc5a34961 100644 --- a/libgfortran/generated/matmul_r4.c +++ b/libgfortran/generated/matmul_r4.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_REAL_4) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_r4 (gfc_array_r4 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_r4 (gfc_array_r4 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_REAL_4 *restrict abase_x; + const GFC_REAL_4 *restrict bbase_y; + GFC_REAL_4 *restrict dest_y; + GFC_REAL_4 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_4) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_r4 (gfc_array_r4 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_REAL_4 *restrict abase_x; + const GFC_REAL_4 *restrict bbase_y; + GFC_REAL_4 *restrict dest_y; + GFC_REAL_4 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_4) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif diff --git a/libgfortran/generated/matmul_r8.c b/libgfortran/generated/matmul_r8.c index 72560f111d4..926a860e386 100644 --- a/libgfortran/generated/matmul_r8.c +++ b/libgfortran/generated/matmul_r8.c @@ -36,16 +36,29 @@ Boston, MA 02110-1301, USA. */ #if defined (HAVE_GFC_REAL_8) -/* This is a C version of the following fortran pseudo-code. The key - point is the loop order -- we access all arrays column-first, which - improves the performance enough to boost galgel spec score by 50%. +/* The order of loops is different in the case of plain matrix + multiplication C=MATMUL(A,B), and in the frequent special case where + the argument A is the temporary result of a TRANSPOSE intrinsic: + C=MATMUL(TRANSPOSE(A),B). Transposed temporaries are detected by + looking at their strides. + + The equivalent Fortran pseudo-code is: DIMENSION A(M,COUNT), B(COUNT,N), C(M,N) - C = 0 - DO J=1,N - DO K=1,COUNT + IF (.NOT.IS_TRANSPOSED(A)) THEN + C = 0 + DO J=1,N + DO K=1,COUNT + DO I=1,M + C(I,J) = C(I,J)+A(I,K)*B(K,J) + ELSE + DO J=1,N DO I=1,M - C(I,J) = C(I,J)+A(I,K)*B(K,J) + S = 0 + DO K=1,COUNT + S = S+A(I,K)+B(K,J) + C(I,J) = S + ENDIF */ extern void matmul_r8 (gfc_array_r8 * const restrict retarray, @@ -204,7 +217,28 @@ matmul_r8 (gfc_array_r8 * const restrict retarray, } } } - else + else if (rxstride == 1 && aystride == 1 && bxstride == 1) + { + const GFC_REAL_8 *restrict abase_x; + const GFC_REAL_8 *restrict bbase_y; + GFC_REAL_8 *restrict dest_y; + GFC_REAL_8 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_8) 0; + for (n = 0; n < count; n++) + s += abase_x[n] * bbase_y[n]; + dest_y[x] = s; + } + } + } + else if (axstride < aystride) { for (y = 0; y < ycount; y++) for (x = 0; x < xcount; x++) @@ -216,6 +250,27 @@ matmul_r8 (gfc_array_r8 * const restrict retarray, /* dest[x,y] += a[x,n] * b[n,y] */ dest[x*rxstride + y*rystride] += abase[x*axstride + n*aystride] * bbase[n*bxstride + y*bystride]; } + else + { + const GFC_REAL_8 *restrict abase_x; + const GFC_REAL_8 *restrict bbase_y; + GFC_REAL_8 *restrict dest_y; + GFC_REAL_8 s; + + for (y = 0; y < ycount; y++) + { + bbase_y = &bbase[y*bystride]; + dest_y = &dest[y*rystride]; + for (x = 0; x < xcount; x++) + { + abase_x = &abase[x*axstride]; + s = (GFC_REAL_8) 0; + for (n = 0; n < count; n++) + s += abase_x[n*aystride] * bbase_y[n*bxstride]; + dest_y[x*rxstride] = s; + } + } + } } #endif |