Sources/FaceMaker/ORT.swift

Swift source for Making faces, 189 lines. Raw file

import CONNXRuntime
import Foundation

enum ORTError: LocalizedError {
    case runtime(String)

    var errorDescription: String? {
        switch self {
        case .runtime(let message): "ONNX Runtime: \(message)"
        }
    }
}

struct ORTTensor {
    let shape: [Int64]
    var data: [Float]
}

/// A loaded ONNX model. The same session can run one face at a time; the
/// face engine keeps it on its own actor.
final class ORTSession: @unchecked Sendable {
    private static nonisolated(unsafe) let api: UnsafePointer<OrtApi> =
        OrtGetApiBase().pointee.GetApi(UInt32(ORT_API_VERSION))!

    private static nonisolated(unsafe) let env: OpaquePointer = {
        var env: OpaquePointer?
        let status = api.pointee.CreateEnv(ORT_LOGGING_LEVEL_ERROR, "FaceMaker", &env)
        precondition(status == nil && env != nil, "OrtCreateEnv failed")
        return env!
    }()

    private let session: OpaquePointer
    private let allocator: UnsafeMutablePointer<OrtAllocator>
    let inputNames: [String]
    let outputNames: [String]

    /// Serializes `CreateSession` across threads. ONNX Runtime lazily
    /// populates a global op-schema registry on first graph resolve, and that
    /// registration is not thread-safe — two sessions being created at once
    /// (e.g. the generator actor and the face-inversion actor) can segfault
    /// inside the graph transformer. All session creation goes through this.
    private static nonisolated(unsafe) let creationLock = NSLock()

    init(modelPath: String, useCoreML: Bool = false) throws {
        Self.creationLock.lock()
        defer { Self.creationLock.unlock() }
        let api = Self.api

        var options: OpaquePointer?
        try Self.check(api.pointee.CreateSessionOptions(&options))
        defer { api.pointee.ReleaseSessionOptions(options) }
        try Self.check(api.pointee.SetSessionGraphOptimizationLevel(options, ORT_ENABLE_ALL))

        if useCoreML {
            let cache = Self.coreMLCacheDirectory()
            let keys = ["ModelFormat", "MLComputeUnits", "ModelCacheDirectory"]
            let values = ["MLProgram", "ALL", cache]
            var keyPointers = keys.map { UnsafePointer<CChar>(strdup($0)) }
            var valuePointers = values.map { UnsafePointer<CChar>(strdup($0)) }
            defer {
                keyPointers.forEach { free(UnsafeMutablePointer(mutating: $0)) }
                valuePointers.forEach { free(UnsafeMutablePointer(mutating: $0)) }
            }
            if let status = api.pointee.SessionOptionsAppendExecutionProvider(
                options, "CoreML", &keyPointers, &valuePointers, keys.count)
            {
                api.pointee.ReleaseStatus(status)
            }
        }

        var session: OpaquePointer?
        try Self.check(modelPath.withCString { path in
            api.pointee.CreateSession(Self.env, path, options, &session)
        })
        guard let session else { throw ORTError.runtime("CreateSession returned nil") }
        self.session = session

        var allocator: UnsafeMutablePointer<OrtAllocator>?
        try Self.check(api.pointee.GetAllocatorWithDefaultOptions(&allocator))
        self.allocator = allocator!

        func names(
            count: (OpaquePointer?, UnsafeMutablePointer<Int>?) -> OrtStatusPtr?,
            name: (OpaquePointer?, Int, UnsafeMutablePointer<OrtAllocator>?,
                   UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>?) -> OrtStatusPtr?
        ) throws -> [String] {
            var total = 0
            try Self.check(count(session, &total))
            return try (0..<total).map { index in
                var raw: UnsafeMutablePointer<CChar>?
                try Self.check(name(session, index, allocator, &raw))
                defer { allocator!.pointee.Free(allocator, raw) }
                return String(cString: raw!)
            }
        }
        self.inputNames = try names(
            count: { api.pointee.SessionGetInputCount($0, $1) },
            name: { api.pointee.SessionGetInputName($0, $1, $2, $3) })
        self.outputNames = try names(
            count: { api.pointee.SessionGetOutputCount($0, $1) },
            name: { api.pointee.SessionGetOutputName($0, $1, $2, $3) })
    }

    deinit {
        Self.api.pointee.ReleaseSession(session)
    }

    /// One Core ML compile cache in the OS temp directory. Reused across
    /// launches. macOS deletes it after the app has not been used.
    private static func coreMLCacheDirectory() -> String {
        let url = FileManager.default.temporaryDirectory
            .appendingPathComponent("com.lewpen.facemaker.coreml", isDirectory: true)
        try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
        return url.path
    }

    func run(_ inputs: [String: ORTTensor]) throws -> [ORTTensor] {
        let api = Self.api

        var memoryInfo: OpaquePointer?
        try Self.check(api.pointee.CreateCpuMemoryInfo(OrtArenaAllocator, OrtMemTypeDefault, &memoryInfo))
        defer { api.pointee.ReleaseMemoryInfo(memoryInfo) }

        var inputValues: [OpaquePointer?] = []
        defer { inputValues.forEach { api.pointee.ReleaseValue($0) } }

        var buffers: [[Float]] = []
        for name in inputNames {
            guard let tensor = inputs[name] else {
                throw ORTError.runtime("missing input tensor '\(name)'")
            }
            buffers.append(tensor.data)
            var value: OpaquePointer?
            let byteCount = tensor.data.count * MemoryLayout<Float>.stride
            try buffers[buffers.count - 1].withUnsafeMutableBufferPointer { buffer in
                try tensor.shape.withUnsafeBufferPointer { shape in
                    try Self.check(api.pointee.CreateTensorWithDataAsOrtValue(
                        memoryInfo, buffer.baseAddress, byteCount,
                        shape.baseAddress, tensor.shape.count,
                        ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &value))
                }
            }
            inputValues.append(value)
        }

        var inputNamePointers = inputNames.map { UnsafePointer<CChar>(strdup($0)) }
        var outputNamePointers = outputNames.map { UnsafePointer<CChar>(strdup($0)) }
        defer {
            inputNamePointers.forEach { free(UnsafeMutablePointer(mutating: $0)) }
            outputNamePointers.forEach { free(UnsafeMutablePointer(mutating: $0)) }
        }

        var outputValues = [OpaquePointer?](repeating: nil, count: outputNames.count)
        defer { outputValues.forEach { api.pointee.ReleaseValue($0) } }

        try withExtendedLifetime(buffers) {
            try Self.check(api.pointee.Run(
                session, nil,
                &inputNamePointers, &inputValues, inputNames.count,
                &outputNamePointers, outputNames.count, &outputValues))
        }

        return try outputValues.map { value in
            var typeShape: OpaquePointer?
            try Self.check(api.pointee.GetTensorTypeAndShape(value, &typeShape))
            defer { api.pointee.ReleaseTensorTypeAndShapeInfo(typeShape) }

            var dimCount = 0
            try Self.check(api.pointee.GetDimensionsCount(typeShape, &dimCount))
            var shape = [Int64](repeating: 0, count: dimCount)
            try Self.check(api.pointee.GetDimensions(typeShape, &shape, dimCount))

            var elementCount = 0
            try Self.check(api.pointee.GetTensorShapeElementCount(typeShape, &elementCount))

            var raw: UnsafeMutableRawPointer?
            try Self.check(api.pointee.GetTensorMutableData(value, &raw))
            let floats = raw!.bindMemory(to: Float.self, capacity: elementCount)
            return ORTTensor(shape: shape, data: Array(UnsafeBufferPointer(start: floats, count: elementCount)))
        }
    }

    private static func check(_ status: OrtStatusPtr?) throws {
        guard let status else { return }
        let message = String(cString: api.pointee.GetErrorMessage(status)!)
        api.pointee.ReleaseStatus(status)
        throw ORTError.runtime(message)
    }
}