Swift RC4与Objective RC4性能

Question

我一直试图重写一个Rc4算法，从目标c到斯威夫特，以检验苹果(现在老了)的说法，它运行得更快。然而，一定有什么地方，我正在做一些可怕的错误，在这些时间，我得到

这是目标c代码：

+(NSString*)Rc4:(NSString*)aInput key:(NSString *)aKey {
    NSMutableArray *iS = [[NSMutableArray alloc] initWithCapacity:256];
    NSMutableArray *iK = [[NSMutableArray alloc] initWithCapacity:256];

    for (int i = 0; i <256;i++){
        [iS addObject:[NSNumber numberWithInt:i]];
    }

    for(short i=0;i<256;i++){
        UniChar c = [aKey characterAtIndex:i%aKey.length];
        [iK addObject:[NSNumber numberWithChar:c]];
    }
    int j=2;
    for (int i=0; i<255;i++){
        int is = [[iS objectAtIndex:i]  intValue];
        UniChar ik = (UniChar)[[iK objectAtIndex:i]charValue];

        j= (j+is+ik)%256;
        NSNumber *temp = [iS objectAtIndex:i];
        [iS replaceObjectAtIndex:i withObject:[iS objectAtIndex:j]];
        [iS replaceObjectAtIndex:j withObject:temp];
    }

    int i =0;
    j=0;
    NSString *result = aInput;

    for (short x=0;x<[aInput length]; x++){
        i = (i+1)%256;

        int is = [[iS objectAtIndex:i]intValue];
        j=(j+is)%256;

        int is_i = [[iS objectAtIndex:i]intValue];
        int is_j = [[iS objectAtIndex:j]intValue];

        int t= (is_i+is_j)%256;
        int iY = [[iS objectAtIndex:t]intValue];

        UniChar ch = (UniChar)[aInput characterAtIndex:x];
        UniChar ch_y=ch^iY;
        //NSLog(ch);
        //NSLog(iY);

        result = [result stringByReplacingCharactersInRange:NSMakeRange(x,1) withString:
                  [NSString stringWithCharacters:&ch_y length:1] ];
    }
    [iS release];
    [iK release];
    return result;
}

这使用-O3运行得非常快，我得到的时间如下：

100次跑:0.006秒

键: 6f7e2a3d744a3b5859725f412f (128位)

输入："MySecretCodeToBeEncryptionSoNobodySeesIt“

这是我使用Swift以同样的方式实现它的尝试：

extension String {
   subscript (i: Int) -> String {
      return String(Array(self)[i])
   }
}
extension Character {
  func unicodeValue() -> UInt32 {
    for s in String(self).unicodeScalars {
      return s.value
    }
    return 0

    }
  }
func Rc4(input:String, key:String)-> String{
  var iS = Array(count:256, repeatedValue: 0)
  var iK = Array(count:256, repeatedValue: "")
  var keyLength = countElements(key)

  for var i = 0; i < 256; i++ {
    iS[i] = i;
  }

  for var i = 0; i < 256 ; i++ {
    var c = key[i%keyLength]
    iK[i] = c;  
  }

  var j = 2

  for var i = 0; i < 255; i++ {
    var iss = iS[i]
    var ik = iK[i]
    // transform string to int
    var ik_x:Character = Character(ik)
    var ikk_xx = Int(ik_x.unicodeValue())

    j = (j+iss+ikk_xx)%256;
    var temp = iS[i]
    iS[i] = iS[j]
    iS[j] = temp
  }

  var i = 0
  j=0
  var result = input
  var eles = countElements(input)
  for var x = 0 ; x<eles ; x++ {
    i = (i+1)%256

    var iss = iS[i]
    j = (j+iss)%256

    var is_i = iS[i]
    var is_j = iS[j]
    var t = (is_i+is_j)%256
    var iY = iS[t]

    var ch = (input[x])
    var ch_x:Character = Character(ch)
    var ch_xx = Int(ch_x.unicodeValue())
    var ch_y = ch_xx^iY
    var start = advance(result.startIndex, x)
    var end = advance(start,1);
    let range = Range(start:start, end:end)
    var maybestring = String(UnicodeScalar(ch_y))
    result = result.stringByReplacingCharactersInRange(range, withString:maybestring)
  }
  return result;
}

我已经尝试实现它，所以它看起来尽可能的目标-c版本。然而，这给我带来了这些可怕的时刻，使用-O

100次跑: 0.5秒

编辑代码现在应该使用我发布的扩展方法在XCode6.1中运行。

我是这样从终端运行的：

xcrun swiftc -O Swift.swift -o swift

Swift.swift是我的文件，斯威夫特是我的可执行文件

Answer 1

通常关于速度的声明并不真正适用于加密算法，它们更适用于我通常所说的“业务逻辑”。比特、字节、16/32/64位字等功能通常难以优化。基本上，加密算法是设计成对这些数据结构进行密集操作的，可以优化的选择相对较少。

以Java为例。虽然它比大多数解释语言快得多，但与C/C++相比确实不太好，更不用说程序集优化的加密算法了。大多数相对较小的代数问题也是如此。

为了使事情更快，您至少应该使用显式数值类型作为您的数字。

Answer 2

在对代码进行了过度的测试之后，我已经将其缩小到了使我的时间变得非常慢的原因。如果我注释掉这段代码，那么iK数组只包含它的初始值。我从运行5秒到1秒。这是一个显著的增长。

for var i = 0; i < 256 ; i++ {
var c = key[i%keyLength]
iK[i] = c;  
}

问题在于这一部分：

var c = key[i%keyLength]

Swift中没有" characterAtIndex (int)“方法，因此我作为一个解决办法来获得characterAtIndex。我用我的分机：

extension String {
  subscript (i: Int) -> String {
    return String(Array(self)[i])
  }
}

但本质上是这样的：

var c = Array(key)[i%keyLength]

而不是目标-c中这个运算的O(1) -(恒定时间)，我们得到的是O(n)的运行时间。