2a859b2014
The cost of vector instructions has always been high under AArch64, in order to add a high cost for inserts/extracts, shuffles and scalarization. This is a conservative approach to limit the scope of unusual SLP vectorization where the codegen ends up being quite poor, but has always been higher than the correct costs would be for any specific core. This relaxes that, reducing the vector insert/extract cost from 3 to 2. It is a generalization of D142359 to all AArch64 cpus. The ScalarizationOverhead is also overridden for integer vector at the same time, to remove the effect of lane 0 being considered free for integer vectors (something that should only be true for float when scalarizing). The lower insert/extract cost will reduce the cost of insert, extracts, shuffling and scalarization. The adjustments of ScalaizationOverhead will increase the cost on integer, especially for small vectors. The end result will be lower cost for float and long-integer types, some higher cost for some smaller vectors. This, along with the raw insert/extract cost being lower, will generally mean more vectorization from the Loop and SLP vectorizer. We may end up regretting this, as that vectorization is not always profitable. In all the benchmarking I have done this is generally an improvement in the overall performance, and I've attempted to address the places where it wasn't with other costmodel adjustments. Differential Revision: https://reviews.llvm.org/D155459
190 lines
10 KiB
LLVM
190 lines
10 KiB
LLVM
; RUN: opt -passes=loop-vectorize -force-vector-width=2 -debug-only=loop-vectorize -disable-output < %s 2>&1 | FileCheck %s --check-prefix=VF_2
|
|
; RUN: opt -passes=loop-vectorize -force-vector-width=4 -debug-only=loop-vectorize -disable-output < %s 2>&1 | FileCheck %s --check-prefix=VF_4
|
|
; RUN: opt -passes=loop-vectorize -force-vector-width=8 -debug-only=loop-vectorize -disable-output < %s 2>&1 | FileCheck %s --check-prefix=VF_8
|
|
; RUN: opt -passes=loop-vectorize -force-vector-width=16 -debug-only=loop-vectorize -disable-output < %s 2>&1 | FileCheck %s --check-prefix=VF_16
|
|
; REQUIRES: asserts
|
|
|
|
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
|
|
target triple = "aarch64--linux-gnueabi"
|
|
|
|
%i8.2 = type {i8, i8}
|
|
define void @i8_factor_2(ptr %data, i64 %n) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
; VF_8-LABEL: Checking a loop in 'i8_factor_2'
|
|
; VF_8: Found an estimated cost of 2 for VF 8 For instruction: %tmp2 = load i8, ptr %tmp0, align 1
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: %tmp3 = load i8, ptr %tmp1, align 1
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: store i8 0, ptr %tmp0, align 1
|
|
; VF_8-NEXT: Found an estimated cost of 2 for VF 8 For instruction: store i8 0, ptr %tmp1, align 1
|
|
; VF_16-LABEL: Checking a loop in 'i8_factor_2'
|
|
; VF_16: Found an estimated cost of 2 for VF 16 For instruction: %tmp2 = load i8, ptr %tmp0, align 1
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: %tmp3 = load i8, ptr %tmp1, align 1
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: store i8 0, ptr %tmp0, align 1
|
|
; VF_16-NEXT: Found an estimated cost of 2 for VF 16 For instruction: store i8 0, ptr %tmp1, align 1
|
|
for.body:
|
|
%i = phi i64 [ 0, %entry ], [ %i.next, %for.body ]
|
|
%tmp0 = getelementptr inbounds %i8.2, ptr %data, i64 %i, i32 0
|
|
%tmp1 = getelementptr inbounds %i8.2, ptr %data, i64 %i, i32 1
|
|
%tmp2 = load i8, ptr %tmp0, align 1
|
|
%tmp3 = load i8, ptr %tmp1, align 1
|
|
store i8 0, ptr %tmp0, align 1
|
|
store i8 0, ptr %tmp1, align 1
|
|
%i.next = add nuw nsw i64 %i, 1
|
|
%cond = icmp slt i64 %i.next, %n
|
|
br i1 %cond, label %for.body, label %for.end
|
|
|
|
for.end:
|
|
ret void
|
|
}
|
|
|
|
%i16.2 = type {i16, i16}
|
|
define void @i16_factor_2(ptr %data, i64 %n) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
; VF_4-LABEL: Checking a loop in 'i16_factor_2'
|
|
; VF_4: Found an estimated cost of 2 for VF 4 For instruction: %tmp2 = load i16, ptr %tmp0, align 2
|
|
; VF_4-NEXT: Found an estimated cost of 0 for VF 4 For instruction: %tmp3 = load i16, ptr %tmp1, align 2
|
|
; VF_4-NEXT: Found an estimated cost of 0 for VF 4 For instruction: store i16 0, ptr %tmp0, align 2
|
|
; VF_4-NEXT: Found an estimated cost of 2 for VF 4 For instruction: store i16 0, ptr %tmp1, align 2
|
|
; VF_8-LABEL: Checking a loop in 'i16_factor_2'
|
|
; VF_8: Found an estimated cost of 2 for VF 8 For instruction: %tmp2 = load i16, ptr %tmp0, align 2
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: %tmp3 = load i16, ptr %tmp1, align 2
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: store i16 0, ptr %tmp0, align 2
|
|
; VF_8-NEXT: Found an estimated cost of 2 for VF 8 For instruction: store i16 0, ptr %tmp1, align 2
|
|
; VF_16-LABEL: Checking a loop in 'i16_factor_2'
|
|
; VF_16: Found an estimated cost of 4 for VF 16 For instruction: %tmp2 = load i16, ptr %tmp0, align 2
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: %tmp3 = load i16, ptr %tmp1, align 2
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: store i16 0, ptr %tmp0, align 2
|
|
; VF_16-NEXT: Found an estimated cost of 4 for VF 16 For instruction: store i16 0, ptr %tmp1, align 2
|
|
for.body:
|
|
%i = phi i64 [ 0, %entry ], [ %i.next, %for.body ]
|
|
%tmp0 = getelementptr inbounds %i16.2, ptr %data, i64 %i, i32 0
|
|
%tmp1 = getelementptr inbounds %i16.2, ptr %data, i64 %i, i32 1
|
|
%tmp2 = load i16, ptr %tmp0, align 2
|
|
%tmp3 = load i16, ptr %tmp1, align 2
|
|
store i16 0, ptr %tmp0, align 2
|
|
store i16 0, ptr %tmp1, align 2
|
|
%i.next = add nuw nsw i64 %i, 1
|
|
%cond = icmp slt i64 %i.next, %n
|
|
br i1 %cond, label %for.body, label %for.end
|
|
|
|
for.end:
|
|
ret void
|
|
}
|
|
|
|
%i32.2 = type {i32, i32}
|
|
define void @i32_factor_2(ptr %data, i64 %n) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
; VF_2-LABEL: Checking a loop in 'i32_factor_2'
|
|
; VF_2: Found an estimated cost of 2 for VF 2 For instruction: %tmp2 = load i32, ptr %tmp0, align 4
|
|
; VF_2-NEXT: Found an estimated cost of 0 for VF 2 For instruction: %tmp3 = load i32, ptr %tmp1, align 4
|
|
; VF_2-NEXT: Found an estimated cost of 0 for VF 2 For instruction: store i32 0, ptr %tmp0, align 4
|
|
; VF_2-NEXT: Found an estimated cost of 2 for VF 2 For instruction: store i32 0, ptr %tmp1, align 4
|
|
; VF_4-LABEL: Checking a loop in 'i32_factor_2'
|
|
; VF_4: Found an estimated cost of 2 for VF 4 For instruction: %tmp2 = load i32, ptr %tmp0, align 4
|
|
; VF_4-NEXT: Found an estimated cost of 0 for VF 4 For instruction: %tmp3 = load i32, ptr %tmp1, align 4
|
|
; VF_4-NEXT: Found an estimated cost of 0 for VF 4 For instruction: store i32 0, ptr %tmp0, align 4
|
|
; VF_4-NEXT: Found an estimated cost of 2 for VF 4 For instruction: store i32 0, ptr %tmp1, align 4
|
|
; VF_8-LABEL: Checking a loop in 'i32_factor_2'
|
|
; VF_8: Found an estimated cost of 4 for VF 8 For instruction: %tmp2 = load i32, ptr %tmp0, align 4
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: %tmp3 = load i32, ptr %tmp1, align 4
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: store i32 0, ptr %tmp0, align 4
|
|
; VF_8-NEXT: Found an estimated cost of 4 for VF 8 For instruction: store i32 0, ptr %tmp1, align 4
|
|
; VF_16-LABEL: Checking a loop in 'i32_factor_2'
|
|
; VF_16: Found an estimated cost of 8 for VF 16 For instruction: %tmp2 = load i32, ptr %tmp0, align 4
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: %tmp3 = load i32, ptr %tmp1, align 4
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: store i32 0, ptr %tmp0, align 4
|
|
; VF_16-NEXT: Found an estimated cost of 8 for VF 16 For instruction: store i32 0, ptr %tmp1, align 4
|
|
for.body:
|
|
%i = phi i64 [ 0, %entry ], [ %i.next, %for.body ]
|
|
%tmp0 = getelementptr inbounds %i32.2, ptr %data, i64 %i, i32 0
|
|
%tmp1 = getelementptr inbounds %i32.2, ptr %data, i64 %i, i32 1
|
|
%tmp2 = load i32, ptr %tmp0, align 4
|
|
%tmp3 = load i32, ptr %tmp1, align 4
|
|
store i32 0, ptr %tmp0, align 4
|
|
store i32 0, ptr %tmp1, align 4
|
|
%i.next = add nuw nsw i64 %i, 1
|
|
%cond = icmp slt i64 %i.next, %n
|
|
br i1 %cond, label %for.body, label %for.end
|
|
|
|
for.end:
|
|
ret void
|
|
}
|
|
|
|
%i64.2 = type {i64, i64}
|
|
define void @i64_factor_2(ptr %data, i64 %n) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
; VF_2-LABEL: Checking a loop in 'i64_factor_2'
|
|
; VF_2: Found an estimated cost of 2 for VF 2 For instruction: %tmp2 = load i64, ptr %tmp0, align 8
|
|
; VF_2-NEXT: Found an estimated cost of 0 for VF 2 For instruction: %tmp3 = load i64, ptr %tmp1, align 8
|
|
; VF_2-NEXT: Found an estimated cost of 0 for VF 2 For instruction: store i64 0, ptr %tmp0, align 8
|
|
; VF_2-NEXT: Found an estimated cost of 2 for VF 2 For instruction: store i64 0, ptr %tmp1, align 8
|
|
; VF_4-LABEL: Checking a loop in 'i64_factor_2'
|
|
; VF_4: Found an estimated cost of 4 for VF 4 For instruction: %tmp2 = load i64, ptr %tmp0, align 8
|
|
; VF_4-NEXT: Found an estimated cost of 0 for VF 4 For instruction: %tmp3 = load i64, ptr %tmp1, align 8
|
|
; VF_4-NEXT: Found an estimated cost of 0 for VF 4 For instruction: store i64 0, ptr %tmp0, align 8
|
|
; VF_4-NEXT: Found an estimated cost of 4 for VF 4 For instruction: store i64 0, ptr %tmp1, align 8
|
|
; VF_8-LABEL: Checking a loop in 'i64_factor_2'
|
|
; VF_8: Found an estimated cost of 8 for VF 8 For instruction: %tmp2 = load i64, ptr %tmp0, align 8
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: %tmp3 = load i64, ptr %tmp1, align 8
|
|
; VF_8-NEXT: Found an estimated cost of 0 for VF 8 For instruction: store i64 0, ptr %tmp0, align 8
|
|
; VF_8-NEXT: Found an estimated cost of 8 for VF 8 For instruction: store i64 0, ptr %tmp1, align 8
|
|
; VF_16-LABEL: Checking a loop in 'i64_factor_2'
|
|
; VF_16: Found an estimated cost of 16 for VF 16 For instruction: %tmp2 = load i64, ptr %tmp0, align 8
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: %tmp3 = load i64, ptr %tmp1, align 8
|
|
; VF_16-NEXT: Found an estimated cost of 0 for VF 16 For instruction: store i64 0, ptr %tmp0, align 8
|
|
; VF_16-NEXT: Found an estimated cost of 16 for VF 16 For instruction: store i64 0, ptr %tmp1, align 8
|
|
for.body:
|
|
%i = phi i64 [ 0, %entry ], [ %i.next, %for.body ]
|
|
%tmp0 = getelementptr inbounds %i64.2, ptr %data, i64 %i, i32 0
|
|
%tmp1 = getelementptr inbounds %i64.2, ptr %data, i64 %i, i32 1
|
|
%tmp2 = load i64, ptr %tmp0, align 8
|
|
%tmp3 = load i64, ptr %tmp1, align 8
|
|
store i64 0, ptr %tmp0, align 8
|
|
store i64 0, ptr %tmp1, align 8
|
|
%i.next = add nuw nsw i64 %i, 1
|
|
%cond = icmp slt i64 %i.next, %n
|
|
br i1 %cond, label %for.body, label %for.end
|
|
|
|
for.end:
|
|
ret void
|
|
}
|
|
|
|
%i64.8 = type {i64, i64, i64, i64, i64, i64, i64, i64}
|
|
define void @i64_factor_8(ptr %data, i64 %n) {
|
|
entry:
|
|
br label %for.body
|
|
|
|
; The interleave factor in this test is 8, which is greater than the maximum
|
|
; allowed factor for AArch64 (4). Thus, we will fall back to the basic TTI
|
|
; implementation for determining the cost of the interleaved load group. The
|
|
; stores do not form a legal interleaved group because the group would contain
|
|
; gaps.
|
|
;
|
|
; VF_2-LABEL: Checking a loop in 'i64_factor_8'
|
|
; VF_2: Found an estimated cost of 16 for VF 2 For instruction: %tmp2 = load i64, ptr %tmp0, align 8
|
|
; VF_2-NEXT: Found an estimated cost of 0 for VF 2 For instruction: %tmp3 = load i64, ptr %tmp1, align 8
|
|
; VF_2-NEXT: Found an estimated cost of 8 for VF 2 For instruction: store i64 0, ptr %tmp0, align 8
|
|
; VF_2-NEXT: Found an estimated cost of 8 for VF 2 For instruction: store i64 0, ptr %tmp1, align 8
|
|
for.body:
|
|
%i = phi i64 [ 0, %entry ], [ %i.next, %for.body ]
|
|
%tmp0 = getelementptr inbounds %i64.8, ptr %data, i64 %i, i32 2
|
|
%tmp1 = getelementptr inbounds %i64.8, ptr %data, i64 %i, i32 6
|
|
%tmp2 = load i64, ptr %tmp0, align 8
|
|
%tmp3 = load i64, ptr %tmp1, align 8
|
|
store i64 0, ptr %tmp0, align 8
|
|
store i64 0, ptr %tmp1, align 8
|
|
%i.next = add nuw nsw i64 %i, 1
|
|
%cond = icmp slt i64 %i.next, %n
|
|
br i1 %cond, label %for.body, label %for.end
|
|
|
|
for.end:
|
|
ret void
|
|
}
|