mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
7ca074bd07
This adjusts the standard library test suite to mostly pass on Windows. The remaining failures are due to various cases: - memory corruption (`_swift_stdlib_free` in swiftDemangle) - heap corruption (canGrowUsingRealloc) - withVAList failure (unresolved) - unicode handling on the command line
323 lines
9.3 KiB
Swift
323 lines
9.3 KiB
Swift
// RUN: %target-run-simple-swiftgyb
|
|
// REQUIRES: executable_test
|
|
|
|
// FIXME: No simd module on linux rdar://problem/20795411
|
|
// XFAIL: linux, windows
|
|
|
|
import simd
|
|
import StdlibUnittest
|
|
|
|
|
|
% scalar_types = ['Float', 'Double', 'Int32', 'UInt32']
|
|
% float_types = ['Float', 'Double']
|
|
% ctype = { 'Float':'float', 'Double':'double', 'Int32':'int', 'UInt32':'uint'}
|
|
% component = ['.x','.y','.z','.w']
|
|
|
|
% for type in scalar_types:
|
|
% for cols in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% vectype = ctype[type] + str(cols)
|
|
func same(_ x: ${vectype}, _ y: ${vectype}) -> Bool {
|
|
for i in 0..<${cols} {
|
|
// Workaround <rdar://problem/18900352>
|
|
% if type in float_types:
|
|
if x[i] != y[i] && !(x[i].isNaN && y[i].isNaN) { return false }
|
|
% else:
|
|
if x[i] != y[i] { return false }
|
|
% end
|
|
}
|
|
return true
|
|
}
|
|
% if type in float_types:
|
|
// Workaround <rdar://problem/18900352>
|
|
% for rows in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% mattype = ctype[type] + str(cols) + 'x' + str(rows)
|
|
func same(_ x: ${mattype}, _ y: ${mattype}) -> Bool {
|
|
for i in 0..<${cols} {
|
|
if !same(x[i], y[i]) { return false }
|
|
}
|
|
return true
|
|
}
|
|
% end # for rows in [2,3,4]
|
|
% end # if type in float_types
|
|
% end # for cols in [2,3,4]
|
|
% end # for type in scalar_types
|
|
|
|
|
|
|
|
/*
|
|
func same<M: SIMDMatrixType>(_ x:M, _ y:M) -> Bool {
|
|
for i in 0 ..< x.columns {
|
|
if (!same(x[i], y[i])) { return false }
|
|
}
|
|
return true
|
|
}
|
|
*/
|
|
|
|
var simdTestSuite = TestSuite("simd")
|
|
|
|
simdTestSuite.test("sizes") {
|
|
// C interop requires that vector be the right size.
|
|
expectEqual(8, MemoryLayout<float2>.size)
|
|
expectEqual(16, MemoryLayout<float3>.size)
|
|
expectEqual(16, MemoryLayout<float4>.size)
|
|
expectEqual(8, MemoryLayout<int2>.size)
|
|
expectEqual(16, MemoryLayout<int3>.size)
|
|
expectEqual(16, MemoryLayout<int4>.size)
|
|
expectEqual(16, MemoryLayout<double2>.size)
|
|
expectEqual(32, MemoryLayout<double3>.size)
|
|
expectEqual(32, MemoryLayout<double4>.size)
|
|
|
|
expectEqual(16, MemoryLayout<float2x2>.size)
|
|
expectEqual(32, MemoryLayout<float2x3>.size)
|
|
expectEqual(32, MemoryLayout<float2x4>.size)
|
|
expectEqual(24, MemoryLayout<float3x2>.size)
|
|
expectEqual(48, MemoryLayout<float3x3>.size)
|
|
expectEqual(48, MemoryLayout<float3x4>.size)
|
|
expectEqual(32, MemoryLayout<float4x2>.size)
|
|
expectEqual(64, MemoryLayout<float4x3>.size)
|
|
expectEqual(64, MemoryLayout<float4x4>.size)
|
|
|
|
expectEqual(32, MemoryLayout<double2x2>.size)
|
|
expectEqual(64, MemoryLayout<double2x3>.size)
|
|
expectEqual(64, MemoryLayout<double2x4>.size)
|
|
expectEqual(48, MemoryLayout<double3x2>.size)
|
|
expectEqual(96, MemoryLayout<double3x3>.size)
|
|
expectEqual(96, MemoryLayout<double3x4>.size)
|
|
expectEqual(64, MemoryLayout<double4x2>.size)
|
|
expectEqual(128, MemoryLayout<double4x3>.size)
|
|
expectEqual(128, MemoryLayout<double4x4>.size)
|
|
}
|
|
|
|
simdTestSuite.test("alignment") {
|
|
struct GenericLayout<T> {
|
|
let t: T = 0 as! T
|
|
let v: int4 = [1,2,3,4]
|
|
}
|
|
|
|
let g = GenericLayout<Int>()
|
|
expectEqual(0, g.t)
|
|
expectEqual([1,2,3,4], g.v)
|
|
}
|
|
|
|
|
|
simdTestSuite.test("vector init") {
|
|
% for type in scalar_types:
|
|
% for size in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% vectype = ctype[type] + str(size)
|
|
% vec = 'v_' + vectype
|
|
|
|
// Check empty initializer.
|
|
var ${vec} = ${vectype}()
|
|
expectEqualTest(${[0]*size}, ${vec}, sameValue: same)
|
|
|
|
// Check literal initializer.
|
|
${vec} = ${vectype}(2)
|
|
expectEqualTest(${[2]*size}, ${vec}, sameValue: same)
|
|
|
|
// Check scalar initializer.
|
|
expectEqualTest(${vectype}(${type}(2)), ${vec}, sameValue: same)
|
|
|
|
// Check elementwise initializer.
|
|
${vec} = ${vectype}(${', '.join(map(lambda i: str(i), range(size)))})
|
|
expectEqualTest(${range(size)}, ${vec}, sameValue: same)
|
|
|
|
// Check labeled elementwise initializer.
|
|
${vec} = ${vectype}(${', '.join(map(lambda i:
|
|
component[i][1:] + ':' + str(i),
|
|
range(size)))})
|
|
expectEqualTest(${range(size)}, ${vec}, sameValue: same)
|
|
|
|
// Previous checks implicitly use the array initializer, so we're good
|
|
// with that one already.
|
|
|
|
% end # for size in [2,3,4]
|
|
% end # for type in scalar_types
|
|
}
|
|
|
|
simdTestSuite.test("vector elements") {
|
|
% for type in scalar_types:
|
|
% for size in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% vectype = ctype[type] + str(size)
|
|
% vec = 'v_' + vectype
|
|
var ${vec} = ${vectype}()
|
|
|
|
// Check getting and setting .xyzw
|
|
% for i in range(size):
|
|
${vec + component[i]} = ${2*i}
|
|
expectEqual(${vec + component[i]}, ${2*i})
|
|
% end
|
|
|
|
// Check getting and setting [i]
|
|
for i in 0..<${size} { ${vec}[i] = ${vec}[i]/2 }
|
|
expectEqualTest(${vec}, ${range(size)}, sameValue: same)
|
|
|
|
% end # for size in [2,3,4]
|
|
% end # for type in scalar_types
|
|
}
|
|
|
|
% for type in scalar_types:
|
|
// ----
|
|
% if type not in float_types:
|
|
// ----
|
|
% for size in [2,3,4]:
|
|
// ----
|
|
% vectype = ctype[type] + str(size)
|
|
|
|
simdTestSuite.test("${vectype} wrapping arithmetic") {
|
|
|
|
expectEqual(${vectype}(.max) &+ ${vectype}(1),
|
|
${vectype}(.min))
|
|
|
|
expectEqual(${vectype}(.min) &- ${vectype}(1),
|
|
${vectype}(.max))
|
|
|
|
expectEqual(${vectype}(.max) &* ${vectype}(.max),
|
|
${vectype}(1))
|
|
expectEqual(${vectype}(.max) &* .max,
|
|
${vectype}(1))
|
|
expectEqual(.max &* ${vectype}(.max),
|
|
${vectype}(1))
|
|
}
|
|
|
|
% end
|
|
% end
|
|
% end
|
|
|
|
simdTestSuite.test("vector distance") {
|
|
% for type in float_types:
|
|
let ${ctype[type]}2_x = ${ctype[type]}2(0,5)
|
|
let ${ctype[type]}2_y = ${ctype[type]}2(3,1)
|
|
expectEqual(5, distance(${ctype[type]}2_x, ${ctype[type]}2_y))
|
|
expectEqual(0, distance(${ctype[type]}2_x, ${ctype[type]}2_x))
|
|
expectEqual(25, distance_squared(${ctype[type]}2_x, ${ctype[type]}2_y))
|
|
expectEqual(0, distance_squared(${ctype[type]}2_x, ${ctype[type]}2_x))
|
|
|
|
let ${ctype[type]}3_x = ${ctype[type]}3(-1,-2,-4)
|
|
let ${ctype[type]}3_y = ${ctype[type]}3( 1, 1, 2)
|
|
expectEqual(7, distance(${ctype[type]}3_x, ${ctype[type]}3_y))
|
|
expectEqual(0, distance(${ctype[type]}3_x, ${ctype[type]}3_x))
|
|
expectEqual(49, distance_squared(${ctype[type]}3_x, ${ctype[type]}3_y))
|
|
expectEqual(0, distance_squared(${ctype[type]}3_x, ${ctype[type]}3_x))
|
|
|
|
let ${ctype[type]}4_x = ${ctype[type]}4(-1, 0, 1, 1)
|
|
let ${ctype[type]}4_y = ${ctype[type]}4( 0, 1, 0, 2)
|
|
expectEqual(2, distance(${ctype[type]}4_x, ${ctype[type]}4_y))
|
|
expectEqual(0, distance(${ctype[type]}4_x, ${ctype[type]}4_x))
|
|
expectEqual(4, distance_squared(${ctype[type]}4_x, ${ctype[type]}4_y))
|
|
expectEqual(0, distance_squared(${ctype[type]}4_x, ${ctype[type]}4_x))
|
|
% end # for type in float_types
|
|
}
|
|
|
|
simdTestSuite.test("matrix init") {
|
|
% for type in float_types:
|
|
% for cols in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% for rows in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% mattype = ctype[type] + str(cols) + 'x' + str(rows)
|
|
% coltype = ctype[type] + str(rows)
|
|
% mat = 'm_' + mattype
|
|
% diagsize = rows if rows < cols else cols
|
|
|
|
// Check empty initializer.
|
|
var ${mat} = ${mattype}()
|
|
expectEqualTest(${mat}, ${mattype}(${[[0]*rows]*cols}), sameValue: same)
|
|
|
|
// Check scalar initializer.
|
|
${mat} = ${mattype}(2)
|
|
for i in 0..<${rows} {
|
|
for j in 0..<${cols} {
|
|
if i == j { expectEqual(${mat}[i, i], 2) }
|
|
else { expectEqual(${mat}[j, i], 0) }
|
|
}
|
|
}
|
|
|
|
// Check diagonal initializer.
|
|
${mat} = ${mattype}(diagonal: ${range(diagsize)})
|
|
for i in 0..<${rows} {
|
|
for j in 0..<${cols} {
|
|
if i == j { expectEqual(${mat}[i, i], ${type}(i)) }
|
|
else { expectEqual(${mat}[j, i], 0) }
|
|
}
|
|
}
|
|
|
|
// All the previous checks implicitly used the column initializer.
|
|
|
|
// Check row initializer.
|
|
${mat} = ${mattype}(rows:[
|
|
% for i in range(rows):
|
|
${range(i*cols, (i+1)*cols)},
|
|
% end # for i
|
|
])
|
|
for i in 0..<${rows} {
|
|
for j in 0..<${cols} {
|
|
expectEqual(${mat}[j, i], ${type}(${cols}*i + j))
|
|
}
|
|
}
|
|
|
|
% end # for rows
|
|
% end # for cols
|
|
% end # for type
|
|
}
|
|
|
|
simdTestSuite.test("matrix elements") {
|
|
% for type in float_types:
|
|
% for cols in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% for rows in [2,3,4]:
|
|
// Workaround <rdar://problem/18900352>
|
|
% mattype = ctype[type] + str(cols) + 'x' + str(rows)
|
|
% coltype = ctype[type] + str(rows)
|
|
% mat = 'm_' + mattype
|
|
% basis = type.lower() + 'basis' + str(cols) + 'x' + str(rows)
|
|
% diagsize = rows if rows < cols else cols
|
|
|
|
// Check getting and setting columns.
|
|
let ${basis} : [${coltype}] = [
|
|
% for i in range(cols):
|
|
[${', '.join(map(lambda j:
|
|
'1' if i == j else '0',
|
|
range(rows)))}],
|
|
% end
|
|
]
|
|
var ${mat} = ${mattype}()
|
|
for i in 0..<${cols} {
|
|
${mat}[i] = ${type}(i+1)*${basis}[i]
|
|
}
|
|
expectEqualTest(
|
|
${mat}, ${mattype}(diagonal:${range(1, diagsize + 1)}), sameValue: same)
|
|
for i in 0..<${cols} {
|
|
expectEqualTest(${mat}[i], ${type}(i + 1)*${basis}[i], sameValue: same)
|
|
}
|
|
|
|
// Check getting and setting elements (and transpose).
|
|
${mat} = ${mattype}()
|
|
for i in 0..<${rows} {
|
|
for j in 0..<${cols} {
|
|
${mat}[j, i] = ${type}(${cols}*i + j)
|
|
}
|
|
}
|
|
var ${'trans'+mat} = ${mat}.transpose
|
|
for j in 0..<${cols} {
|
|
for i in 0..<${rows} {
|
|
expectEqual(${'trans'+mat}[i, j], ${type}(${cols}*i + j))
|
|
}
|
|
}
|
|
|
|
% end # for rows
|
|
% end # for cols
|
|
% end # for type
|
|
}
|
|
|
|
simdTestSuite.test("debug description") {
|
|
expectEqual("SIMD2<Float>(1.0, 2.5)",
|
|
SIMD2<Float>(1.0, 2.5).debugDescription)
|
|
}
|
|
|
|
runAllTests()
|
|
|