File size: 4,334 Bytes
2e08f77 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
import Foundation
import Accelerate
import MetalPerformanceShaders
// Sizes of the matrices: C = A x B.
private let rowsA = 3
private let columnsA = 4
private let rowsB = columnsA
private let columnsB = 2
private let rowsC = rowsA
private let columnsC = columnsB
private var device: MTLDevice!
private var commandQueue: MTLCommandQueue!
private var matrixMultiplication: MPSMatrixMultiplication!
private var matrixA: MPSMatrix!
private var matrixB: MPSMatrix!
private var matrixC: MPSMatrix!
private var arrayA = [Float](repeating: 0, count: rowsA * columnsA)
private var arrayB = [Float](repeating: 0, count: rowsB * columnsB * 2)
private var arrayC = [Float](repeating: 0, count: rowsC * columnsC)
func run() {
randomizeArrays()
initMPS()
}
private func randomizeArrays() {
// Fill up A and B with random floating point numbers (between -1 and +1).
for i in 0..<arrayA.count {
arrayA[i] = Float(i)
}
for i in 0..<arrayB.count {
arrayB[i] = Float(i)
}
print(arrayB)
}
private func initMPS() {
device = MTLCreateSystemDefaultDevice()
guard device != nil else {
fatalError("Error: This device does not support Metal")
}
guard MPSSupportsMTLDevice(device) else {
fatalError("Error: This device does not support Metal Performance Shaders")
}
commandQueue = device.makeCommandQueue()
matrixMultiplication = MPSMatrixMultiplication(device: device, transposeLeft: false, transposeRight: false, resultRows: rowsC, resultColumns: columnsC, interiorColumns: columnsA, alpha: 1, beta: 0)
// For optimal speed, we should use the recommended row stride.
//let rowBytesA = MPSMatrixDescriptor.rowBytes(fromColumns: columnsA, dataType: .float32)
//print("preferred stride \(rowBytesA), my stride \(columnsA * MemoryLayout<Float>.stride)")
// The contents of the arrays are copied into the MTLBuffers. Note that we
// don't copy arrayC into bufferC because it's just zeros (arrayC is only
// used to store the results of the BLAS matrix multiply).
let bufferA = device.makeBuffer(bytes: arrayA, length: rowsA * columnsA * MemoryLayout<Float>.stride, options: [])
let bufferB = device.makeBuffer(bytes: arrayB, length: rowsB * columnsB * MemoryLayout<Float>.stride * 2, options: [])
let bufferC = device.makeBuffer(length: rowsC * columnsC * MemoryLayout<Float>.stride, options: [])
let descA = MPSMatrixDescriptor(dimensions: rowsA, columns: columnsA, rowBytes: columnsA * MemoryLayout<Float>.stride, dataType: .float32)
let descB = MPSMatrixDescriptor(dimensions: rowsB, columns: columnsB, rowBytes: columnsB * MemoryLayout<Float>.stride, dataType: .float32)
let descC = MPSMatrixDescriptor(dimensions: rowsC, columns: columnsC, rowBytes: columnsC * MemoryLayout<Float>.stride, dataType: .float32)
matrixA = MPSMatrix(buffer: bufferA!, descriptor: descA)
matrixB = MPSMatrix(buffer: bufferB!, offset: 0, descriptor: descB)
matrixC = MPSMatrix(buffer: bufferC!, descriptor: descC)
var commandBuffer = commandQueue.makeCommandBuffer()!
matrixMultiplication.encode(commandBuffer: commandBuffer, leftMatrix: matrixA, rightMatrix: matrixB, resultMatrix: matrixC)
commandBuffer.commit()
commandBuffer.waitUntilCompleted()
var contents = bufferC!.contents();
var count = rowsA * columnsB;
var typedPointer = contents.bindMemory(to: Float.self, capacity: count)
var bufferedPointer = UnsafeBufferPointer(start: typedPointer, count: count)
print(Array(bufferedPointer))
print("Offsetted")
matrixA = MPSMatrix(buffer: bufferA!, descriptor: descA)
matrixB = MPSMatrix(buffer: bufferB!, offset: 4 * 2 * 4, descriptor: descB)
matrixC = MPSMatrix(buffer: bufferC!, descriptor: descC)
commandBuffer = commandQueue.makeCommandBuffer()!
matrixMultiplication.encode(commandBuffer: commandBuffer, leftMatrix: matrixA, rightMatrix: matrixB, resultMatrix: matrixC)
commandBuffer.commit()
commandBuffer.waitUntilCompleted()
contents = bufferC!.contents();
count = rowsA * columnsB;
typedPointer = contents.bindMemory(to: Float.self, capacity: count)
bufferedPointer = UnsafeBufferPointer(start: typedPointer, count: count)
print(Array(bufferedPointer))
}
run()
|