Question

这是两个非常相似的Levenshtein Distance algorithms。

Swift实施： https://gist.github.com/bgreenlee/52d93a1d8fa1b8c1f38b

Objective-C实施： https://gist.github.com/boratlibre/1593632

swift一个比ObjC实施慢得多我发送了几个小时来加快速度，但......似乎Swift数组和Strings操作不如objC快。

On 2000 random Strings计算Swift实施比ObjC慢约100（!!!）倍。

老实说，我不知道可能出现什么问题，甚至包括这部分的快速

func levenshtein(aStr: String, bStr: String) -> Int {
// create character arrays
let a = Array(aStr)
let b = Array(bStr)
...

比Objective C

中的整个算法慢几倍

有谁知道如何加快swift计算？

提前谢谢！

追加

经过所有建议的改进后，swift代码看起来像这样。在发布配置中，它比ObjC 4倍。

import Foundation class Array2D { var cols:Int, rows:Int var matrix:UnsafeMutablePointer<Int> init(cols:Int, rows:Int) { self.cols = cols self.rows = rows matrix = UnsafeMutablePointer<Int>(malloc(UInt(cols * rows) * UInt(sizeof(Int)))) for i in 0...cols*rows { matrix[i] = 0 } } subscript(col:Int, row:Int) -> Int { get { return matrix[cols * row + col] as Int } set { matrix[cols*row+col] = newValue } } func colCount() -> Int { return self.cols } func rowCount() -> Int { return self.rows } } extension String { func levenshteinDistanceFromStringSwift(comparingString: NSString) -> Int { let aStr = self let bStr = comparingString // let a = Array(aStr.unicodeScalars) // let b = Array(bStr.unicodeScalars) let a:NSString = aStr let b:NSString = bStr var dist = Array2D(cols: a.length + 1, rows: b.length + 1) for i in 1...a.length { dist[i, 0] = i } for j in 1...b.length { dist[0, j] = j } for i in 1...a.length { for j in 1...b.length { if a.characterAtIndex(i-1) == b.characterAtIndex(j-1) { dist[i, j] = dist[i-1, j-1] // noop } else { dist[i, j] = min( dist[i-1, j] + 1, // deletion dist[i, j-1] + 1, // insertion dist[i-1, j-1] + 1 // substitution ) } } } return dist[a.length, b.length] } func levenshteinDistanceFromStringObjC(comparingString: String) -> Int { let aStr = self let bStr = comparingString //It is really strange, but I should link Objective-C coz dramatic slow swift performance return aStr.compareWithWord(bStr, matchGain: 0, missingCost: 1) } }

的malloc ??的NSString？最后4倍减速？有人需要迅速吗？

Answer 1

Swift代码比Objective-C代码慢的原因有很多。我通过比较两次固定字符串100次来做一个非常简单的测试用例。

Objective-C代码：0.026秒
Swift代码：3.14秒

第一个原因是Swift Character代表“扩展的字形簇”，它可以包含几个Unicode代码点（例如“标志”）。这使得将字符串分解为字符慢。另一方面，Objective-C NSString将字符串存储为一系列UTF-16代码点。

如果您更换

let a = Array(aStr)
let b = Array(bStr)

通过

let a = Array(aStr.utf16)
let b = Array(bStr.utf16)

这样Swift代码也适用于UTF-16序列，然后时间会缩短到1.88秒。

二维数组的分配也很慢。分配速度更快单个一维数组。我在这里找到了一个简单的Array2D类： http://blog.trolieb.com/trouble-multidimensional-arrays-swift/

class Array2D {
    var cols:Int, rows:Int
    var matrix: [Int]


    init(cols:Int, rows:Int) {
        self.cols = cols
        self.rows = rows
        matrix = Array(count:cols*rows, repeatedValue:0)
    }

    subscript(col:Int, row:Int) -> Int {
        get {
            return matrix[cols * row + col]
        }
        set {
            matrix[cols*row+col] = newValue
        }
    }

    func colCount() -> Int {
        return self.cols
    }

    func rowCount() -> Int {
        return self.rows
    }
}

在代码中使用该类

func levenshtein(aStr: String, bStr: String) -> Int {
    let a = Array(aStr.utf16)
    let b = Array(bStr.utf16)

    var dist = Array2D(cols: a.count + 1, rows: b.count + 1)

    for i in 1...a.count {
        dist[i, 0] = i
    }

    for j in 1...b.count {
        dist[0, j] = j
    }

    for i in 1...a.count {
        for j in 1...b.count {
            if a[i-1] == b[j-1] {
                dist[i, j] = dist[i-1, j-1]  // noop
            } else {
                dist[i, j] = min(
                    dist[i-1, j] + 1,  // deletion
                    dist[i, j-1] + 1,  // insertion
                    dist[i-1, j-1] + 1  // substitution
                )
            }
        }
    }

    return dist[a.count, b.count]
}

测试用例中的时间下降到0.84秒。

我在Swift代码中找到的最后一个瓶颈是min()函数。 Swift库有一个内置的min()函数，速度更快。所以只是删除 Swift代码中的自定义函数减少了测试用例的时间 0.04秒，几乎与Objective-C版本一样好。

附录：使用Unicode标量似乎更快一点：

let a = Array(aStr.unicodeScalars)
let b = Array(bStr.unicodeScalars)

并且具有与代理对一起正确工作的优点作为Emojis。

Slow Swift Arrays和Strings性能

1 个答案: