Comparación de velocidad de secuencia Swift vs Objective-C Fibonacci

Tengo un problema. Quiero saber cuál es más rápido (Swift o Objective-C) porque me gustaría elegir uno más rápido / mejor cuando empiezo a desarrollar una aplicación. Según muchas fonts (por ejemplo, WWDC de Apple, o http://www.jessesquires.com/apples-to-apples-part-two/ ), Swift se supone que debe ser más rápido.

Acabo de escribir un progtwig de secuencia simple de Fibonacci recursivo tanto en Swift como en Objective-C.

Sin embargo, cuando ejecuto fib (35) en el simulador, obtengo resultados sorprendentes:

Objetivo-C Resultado:

::: fib :::: 9227465 ::: duración ::: 0.122813 segundos

Resultado rápido

::: fib :::: 9227465 ::: duración ::: 0.606831073760986 segundos

Ahora, incluso ejecuté la versión Swift en todo el nivel de Optimización del comstackdor Swift (para debugging), que es Ninguno, más rápido, más rápido, sin marcar. También juego con el nivel de optimization de generación de código en Ninguno, Rápido … La optimization agresiva más rápida. Sin embargo, todos los resultados de Swift son algo cercanos a 0.6 milisegundos.

Ahora, lo último que puedo pensar es que puedo estar comparando un Apple a Orange? ¿Ves algo que me falta aquí? ¿Hay algo más que tengo que activar (que no sean los niveles de optimization para Swfit Compiler y Apple LLVM Code Generation) para que los progtwigs Swift funcionen más rápido?

¡Cualquier sugerencia o comentario es bienvenido y apreciado! ^^!

Versión Objective-C

-(int)fib:(int)num{ if (num == 0) { return 0; } if (num == 1) { return 1; } return [self fib:num - 1] + [self fib:num - 2]; } 

Versión Swift

 func fib(num: Int) -> Int{ if(num == 0){ return 0; } if(num == 1){ return 1; } return fib(num - 1) + fib(num - 2); } 

Objective-C Time Measurement

  NSTimeInterval start = [[NSDate date] timeIntervalSince1970]; int result = [self fib:35]; NSTimeInterval end = [[NSDate date] timeIntervalSince1970]; NSTimeInterval duration = end - start; NSLog(@":::fib::::%d:::duration:::%f",result,duration); 

Medida del time rápido

 var start = NSDate().timeIntervalSince1970; let result = fib(35); var end = NSDate().timeIntervalSince1970; var duration = end - start; println(":::fib::::\(result) :::duration:::\(duration)"); 

Muchas cosas a tener en count al decidir cuál de los dos lenguajes de progtwigción es más rápido. Hice un par de puntos de reference ( https://github.com/vsco/swift-benchmarks ) entre Swift y Objective-C y encontré que en ciertos casos Swift era más rápido y en otros casos, Objective-C era más rápido. Por ejemplo, el uso de objects estruct en Swift ofrecerá enormes ganancias de performance si necesita operar con una gran cantidad de datos. Por el contrario, el uso de objects no estructurados hizo que Swift sea significativamente más lento que sus contrapartes Objective-C.

Además, la forma en que usa ciertas características en Swift es muy importante para su desempeño. Tome esta function, por ejemplo:

 class func shuffleGenericObjects<T>(inout array:[T]) { for (var i = 0; i < array.count; i++) { let currentObject: T = array[i] let randomIndex = Int(arc4random()) % array.count let randomObject: T = array[randomIndex] array[i] = randomObject; array[randomIndex] = currentObject } } 

Seguro que funciona muy bien para minimizar el código repetitivo, pero cuando ejecuté este método más de 1 millón de objects Int, tardé aproximadamente 32 segundos en completarse. Como opuesto a la implementación no genérica, que solo tomó 0.181 segundos.

También recomiendo no utilizar NSDate funciones de NSDate para la evaluación comparativa en Swift. Encontré algunos errores que causaron que NSDate regrese times incorrectos. Es mucho mejor poner sus puntos de reference en un XCTestCase y usar la function measureBlock() .

La elección de Fibonacci como su punto de reference es un poco irónico, porque en el video WWDC 2014 Advanced Swift usan la secuencia de Fibonacci como un ejemplo de cómo puede escribir una function de memoize genérico que es de varios órdenes de magnitud más rápido.

 func memoize<T: Hashable, U>(body: ((T)->U, T) -> U) -> (T)->U { var memo = [T: U]() var result: ((T)->U)! result = { x in if let q = memo[x] { return q } let r = body(result, x) memo[x] = r return r } return result } 

Donde puede entonces:

 let fib = memoize { fib, x in x < 2 ? x : fib(x - 1) + fib(x - 2) } let result = fib(35) 

Ahora, claramente, es injusto comparar esto con una function de Fibonacci recursiva Objective-C no optimizada, porque esto lo dejará en el polvo. Ni siquiera estoy seguro de estar de acuerdo con todas las conclusiones de la WWDC sobre los méritos de la implementación genérica de memoize Swift. Pero la mejora del performance es sorprendente.


Hay muchos patrones en los que una traducción ingenua del código Objective-C dará como resultado implementaciones más rápidas de Swift. En particular, mucho más dramático que su ejemplo en el que el código Swift fue un poco más lento, me sorprendieron las situaciones simples en las que es bastante fácil escribir una rutina en Swift que luce lógicamente muy similar (o incluso más elegante), pero es mucho, mucho más lento (o al less antes de que el desarrollador de la aplicación refactorice un poco la implementación de Swift).

En pocas palabras, personalmente dudaría en sacar conclusiones simples de Swift es más rápido que Objective-C, o viceversa. Sospecho que hay algunos algorithms / aplicaciones en los que Swift es más rápido y otros en los que no lo es.

Además, usted dice que con respecto a la elección del lenguaje de progtwigción que "le gustaría elegir uno más rápido / mejor". Contestaría que el lenguaje "más rápido" siempre es "mejor" (de lo contrario, todos seguiríamos escribiendo el código de ensamblaje). A menudo, la elección del idioma es less la eficiencia computacional bruta del código, y más la efectividad del desarrollador. Todos debemos elegir el idioma en el que podemos escribir el código más robusto, hacerlo de la manera más rentable, escribir un código que se mantenga con mayor facilidad en el futuro y ofrecer una experiencia de usuario superlativa.

Si ese lenguaje es Swift o Objective-C es una cuestión de opinión y no es para este foro.

Su código se ve bien, pero no puede generalizar la rapidez de un lenguaje de progtwigción en una situación como esa. En el Keynote de Apple del año pasado, dijeron que "orderar objects complejos" era más rápido en Swift. Probablemente hay un par de cosas más rápido en Objective-C, pero en general, se supone que Swift es el lenguaje más rápido.