Tez beta: serialların çeşidlənməsi

Swift Beta'da alqoritmi tətbiq etdim və performansın çox pis olduğunu fərq etdim. Daha dərinləşərək, darboğazlardan birinin serialların çeşidlənməsi kimi sadə bir şey olduğunu başa düşdüm. Müvafiq hissə burada:

 let n = 1000000 var x = [Int](repeating: 0, count: n) for i in 0..<n { x[i] = random() } // start clock here let y = sort(x) // stop clock here 

C ++ 'da oxşar əməliyyat 0.06 saniyə çəkir.

Python'da, 0.6 s (tamsayılar olmadan, yalnız y = sıralanır (x) tamsayılar siyahısı üçün) götürür.

Aşağıdakı əmri tərtib edərkən Swift 6 saniyə çəkir:

 xcrun swift -O3 -sdk 'xcrun --show-sdk-path --sdk macosx' 

Aşağıdakı əmri tərtib edərkən 88 saniyəyə qədər davam edəcək:

 xcrun swift -O0 -sdk 'xcrun --show-sdk-path --sdk macosx' 

Xcode-də "Release" və "Debug" ilə bərabərləşməsi oxşardır.

Burada nədir? C ++ ilə müqayisədə bəzi performans itkisini başa düşə bilərəm, amma təmiz Python ilə müqayisədə 10 dəfə azalma deyil.


Düzenle: mweathers, dəyişən -O3 -Ofast bu kodun demək olar ki, C ++ versiyasını yerinə yetirdiyini fərq etdi! Buna baxmayaraq, -Ofast semantikasını çox yaxşı -Ofast tamsaylı daşqınlar və -Ofast üçün çekləri söndürdü . Məsələn, -Ofast ilə -Ofast aşağıdakı Swift kodu uğursuz işləyir (və zibil -Ofast ):

 let n = 10000000 print(n*n*n*n*n) let x = [Int](repeating: 10, count: n) print(x[n]) 

Beləliklə, biz istədiyimiz şey deyil; Swift'ın mahiyyəti bizim təhlükəsizlik şəbəkələrimizdir. Əlbəttə ki, təhlükəsizlik sistemləri performansa təsir göstərir, lakin proqramları 100 dəfə daha yavaş aparmamalıdırlar. Java artıq dizilərin sərhədlərini yoxladığını xatırlayın və tipik hallarda yavaşlama -ftrapv dəfə azdır. Və C>-ftrapv üçün yoxlamaq üçün -ftrapv və bu yavaş və ya deyil.

Beləliklə, sual: Təhlükəsizlik şəbəkələrini itirmədən Swift-də makul bir performans əldə edə bilərikmi?


Düzenle 2: Çox sadə xətt dövrü ilə bir az daha test etdim

 for i in 0..<n { x[i] = x[i] ^ 12345678 } 

(Burada xor əməliyyatının mənim üçün məclis kodunda müvafiq loop tapmaq asanlaşdırmaq üçün sadəcə var. Mən aşkar etmək üçün asan bir əməliyyat seçməyə çalışdım amma "zərərsiz" mənası ilə bağlı heç bir çekləri tələb etməmək lazım deyil tam daşqınlar ilə.)

Yenə də, -O3 ə qədər böyük bir performans fərqi var idi. Yəni quruluş koduna baxdım:

  • -Ofast mən gözlədiyim hər şeyi alıram. Müvafiq hissə 5 maşın dili təlimatı ilə bir dövrü təşkil edir.

  • -O3 mənim -O3 təsəvvürlərimdən kənara -O3 . Daxili döngü 88 ədəd montaj kodunu alır. Bütün bunları anlamamağa çalışmadım, amma ən şübhəli hissələr 13 çağırışdır "callq_swift_retain" və 13 daha çox "callq_swift_release" çağırır. Yəni , daxili loop 26 subroutine çağırır !


Edit 3: Şərhlərdə, Ferruccio, daxili funksiyaları (məsələn, çeşidləmə) etibar etmədikləri mənada ədalətli olan meyarları istədi. Hesab edirəm ki, aşağıdakı proqram olduqca yaxşı bir nümunədir:

 let n = 10000 var x = [Int](repeating: 1, count: n) for i in 0..<n { for j in 0..<n { x[i] = x[j] } } 

Burada heç bir aritmetik yoxdur, buna görə tam daşqınlarla əlaqədar narahatlığa ehtiyacımız yoxdur. Yaptığımız tək şey dizilərə çox istinad edir. Və nəticələr burada - Swift -O3-ə nisbətən təxminən 500 dəfə itirir -

  • C ++ -O3: 0,05 s
  • C ++ -O0: 0.4 s
  • Java: 0.2 s
  • PyPy ilə Python: 0.5 s
  • Python: 12 s
  • Swift -Hızlı: 0,05 s
  • Swift -O3 23 s
  • Swift -00: 443 s

(Derleyicinin mənasız döngələri tam olaraq optimize edə biləcəyini düşünürsənsə, məsələn, x[i] ^= x[j] dəyişə bilərsiniz və x[0] çıxardığına dair bir print bildirimi əlavə edə bilərsiniz. tarixlər çox oxşar olacaq.)

Və bəli, burada Python tətbiqi tamsaylı və nested loops bir siyahısı ilə axmaq təmiz Python həyata keçirilməsi idi. Bu qeyri-optimallaşdırılmamış Swift-dən çox yavaş olmalıdır. Göründüyü kimi, bir şey Swift və endeksləmə serialları ilə ciddi şəkildə pozulub.


Düzəliş 4: Bu məsələlər (bəzi digər performans məsələləri kimi) Xcode 6 beta 5-də müəyyən edilmişdir.

Sıralamaq üçün indi aşağıdakı vaxtlar var:

  • c>
  • swiftc -Hızlı: 0,1 s
  • swiftc -O: 0.1 s
  • swiftc: 4 s

Daxili döngələr üçün:

  • c>
  • swiftc -Hızlı: 0,3 s
  • swiftc -O: 0.4 s
  • swiftc: 540s

Göründüyü kimi, artıq təhlükəsiz istifadə etmək üçün heç bir səbəb yoxdur - -Ofast (aka- -Ounchecked ); -O bərabər yaxşı kodu istehsal edir.

870
08 июня '14 в 2:53 2014-06-08 02:53 Jukka Suomela 08 iyun 'da 14:53 ' də təyin olunub
@ 9 cavab

Bu testdə, Dr Swift 1.0 indi default azad optimallaşdırma səviyyəsi [-O] istifadə edərək, C kimi sürətli çalışır.


Swift Beta-da tez bir yerə görə sıralama:

 func quicksort_swift(inout a:CInt[], start:Int, end:Int) { if (end - start < 2){ return } var p = a[start + (end - start)/2] var l = start var r = end - 1 while (l <= r){ if (a[l] < p){ l += 1 continue } if (a[r] > p){ r -= 1 continue } var t = a[l] a[l] = a[r] a[r] = t l += 1 r -= 1 } quicksort_swift( start, r + 1) quicksort_swift( r + 1, end) } 

C ilə eyni şey:

 void quicksort_c(int *a, int n) { if (n < 2) return; int p = a[n / 2]; int *l = a; int *r = a + n - 1; while (l <= r) { if (*l < p) { l++; continue; } if (*r > p) { r--; continue; } int t = *l; *l++ = *r; *r-- = t; } quicksort_c(a, r - a + 1); quicksort_c(l, a + n - l); } 

Həm də işləyir:

 var a_swift:CInt[] = [0,5,2,8,1234,-1,2] var a_c:CInt[] = [0,5,2,8,1234,-1,2] quicksort_swift( 0, a_swift.count) quicksort_c( CInt(a_c.count)) // [-1, 0, 2, 2, 5, 8, 1234] // [-1, 0, 2, 2, 5, 8, 1234] 

Həm yazılı olduğu kimi həm də eyni proqramda deyilir.

 var x_swift = CInt[](count: n, repeatedValue: 0) var x_c = CInt[](count: n, repeatedValue: 0) for var i = 0; i < n; ++i { x_swift[i] = CInt(random()) x_c[i] = CInt(random()) } let swift_start:UInt64 = mach_absolute_time(); quicksort_swift( 0, x_swift.count) let swift_stop:UInt64 = mach_absolute_time(); let c_start:UInt64 = mach_absolute_time(); quicksort_c( CInt(x_c.count)) let c_stop:UInt64 = mach_absolute_time(); 

Bu mütləq saatı saniyə çevirir:

 static const uint64_t NANOS_PER_USEC = 1000ULL; static const uint64_t NANOS_PER_MSEC = 1000ULL * NANOS_PER_USEC; static const uint64_t NANOS_PER_SEC = 1000ULL * NANOS_PER_MSEC; mach_timebase_info_data_t timebase_info; uint64_t abs_to_nanos(uint64_t abs) { if ( timebase_info.denom == 0 ) { (void)mach_timebase_info( } return abs * timebase_info.numer / timebase_info.denom; } double abs_to_seconds(uint64_t abs) { return abs_to_nanos(abs) / (double)NANOS_PER_SEC; } 

Kompilyator optimallaşdırma səviyyəsinin xülasəsi:

 [-Onone] no optimizations, the default for debug. [-O] perform optimizations, the default for release. [-Ofast] perform optimizations and disable runtime overflow checks and runtime type checks. 

N = 10_000 üçün [-O no] dan saniyə saniyə:

 Swift: 0.895296452 C: 0.001223848 

Burada n = 10_000 üçün quraşdırılmış Swift ()

 Swift_builtin: 0.77865783 

İşdə [-O] n = 10_000 üçün :

 Swift: 0.045478346 C: 0.000784666 Swift_builtin: 0.032513488 

Gördüyünüz kimi, Swift performansı 20 dəfə yaxşılaşmışdır.

Mweatherin cavabına görə, [-O fast] qəbulu real fərq yaradır və bu müddətlərə n = 10_000 üçün gətirilir :

 Swift: 0.000706745 C: 0.000742374 Swift_builtin: 0.000603576 

n = 1_000_000 üçün :

 Swift: 0.107111846 C: 0.114957179 Swift_sort: 0.092688548 

Müqayisə üçün bu, [-O heç kimə aid deyil] n = 1_000_000 :

 Swift: 142.659763258 C: 0.162065333 Swift_sort: 114.095478272 

Beləliklə, inkişafın bu mərhələsində Swift optimallaşdırmadan təxminən 1000 dəfə daha yavaş idi. Digər tərəfdən, hər iki kompilyator ilə [-O fast], Swift ən yaxşı halda işləmişdir, əgər bir qədər yaxşı olmasa Cdən çox

Qeyd edildiyi kimi, [-O fast] dilin semantikasını dəyişir və potensial təhlükə yaradır. Xcode 5.0 versiyası qeydlərində Apple deyir:

LLVM-də mövcud olan yeni optimallaşdırma səviyyəsi - sürətli, təcavüzkar optimallaşdırma təmin edir. Tezliklə, ən çox kod üçün təhlükəsiz olan üzən nöqtə əməliyyatları üçün, bəzi mühafizəkar məhdudiyyətlər loosens. Bu, əhəmiyyətli yüksək performanslı kompilyator qazanmalarına səbəb ola bilər.

Onlar demək olar ki, qoruyur. Müdrik və ya olmasın, deyə bilmərəm, ancaq deyə bilərəm ki, yüksək dəqiqlikli üzən nöqtə aritmetiğini yerinə yetirmirsinizsə və proqramınızın olmadığından əmin olsanız, azadlığa [-O fast] tamsayı və ya dizi daşması Yüksək performans və daşqın çekləri / dəqiq hesaba ehtiyacınız varsa, başqa bir dil seçin.

BETA 3 UPDATE:

n = 10_000 s [-O] :

 Swift: 0.019697268 C: 0.000718064 Swift_sort: 0.002094721 

Swift ümumiyyətlə bir qədər daha sürətli işləyir və Swift'in daxili çeşidlənməsi əhəmiyyətli dərəcədə dəyişdi.

SON DƏQİQƏ:

[-O No] :

 Swift: 0.678056695 C: 0.000973914 

[-O] :

 Swift: 0.001158492 C: 0.001192406 

[-O təsdiqlənməmiş] :

 Swift: 0.000827764 C: 0.001078914 
428
08 июня '14 в 4:36 2014-06-08 04:36 Yusif Markın İyun 08'14'ündəki 4:36 'də cevabı 2014-06-08 04:36

Tl; DR : Bəli, Swift yalnız tətbiq yavaş-yavaş, indi. Sürətli, rəqəmsal (və digər kod tipləri ehtimal) kodunuza ehtiyacınız varsa, başqa birinə gedin. Gələcəkdə seçiminizi çox qiymətləndirməlisiniz. Bu, daha yüksək səviyyədə yazılmış proqramların çoxu üçün kifayət qədər yaxşı ola bilər.

SIL və LLVM IR-də gördüyümlərdən fərqli olaraq, C> (Objective-C üçün) üçün tətbiq edilə bilən qənaət və relizlər silmək üçün bir dəstə optimallaşdırma tələb olunur, lakin onlar hələ də köçürülməmişlər. Mənimlə birlikdə olduğum nəzəriyyənin (hələ də ... C>

Digər bir çox adamın -Ofast , " -Ofast tamamilə etibarsızdır və dilin semantikasını dəyişir. Mənim üçün, "Əgər onu istifadə edəcəyəmsə, başqa bir dili istifadə edin." Bu dəyişiklik əgər dəyişsə, bu seçimi daha çox qiymətləndirəcəyəm.

-O3 bizə bu nümunə üçün orada swift_release sanki sanki baxmaq swift_retain bir qrup swift_retainswift_release . Optimallaşdırıcı (əksəriyyəti) AFAICT aradan qaldırılmalıdır, çünki bu serialdakı məlumatların əksəriyyətini bilir və bunun (ən azı) ən güclü bir link olduğunu bilir.

O, obyektləri azad edə biləcək funksiyaları çağırmırsa daha çox ayırmamalıdır. Serial konstruktorunun istəniləndən kiçik olan bir sıra geri qaytaracağını düşünmürəm, yəni seçilmiş çox çeklər faydasızdır. O, həmçinin tam sayının 10k-dan yuxarı olmayacağını da bilir, belə ki daşqın çekləri optimallaşdırıla bilər ( -Ofast qəribəlik deyil, -Ofast semantikası səbəbindən (başqa heç bir şey bu dəyişməz və onu əldə edə bilməz, amma 10 kata qədər əlavə Int ) üçün təhlükəsizdir.

border=0

Derleyici, bir dizi ya da bir dizi unsurunu açamaz, yani, xarici bir funksiyadır ve beklenen argümanları alması lazımdır sort() , sort() . Bu bizə birbaşa yavaş getməyə səbəb olan Int dəyərlərindən dolayı istifadə etməyə məcbur edəcək. sort() funksiyası funksiyası (bir neçə metodlu bir metodda deyil) kompilyatora daxil olsaydı və sort() bu dəyişə bilər.

Bu, çox yeni (açıq mənbə) dildir və mən düşünürəm ki, çox şey dəyişikdir, çünki Swift dili ilə əlaqəli insanlar var və hər kəs dilin bitməmiş və dəyişdi

İstifadə olunan kod:

 import Cocoa let swift_start = NSDate.timeIntervalSinceReferenceDate(); let n: Int = 10000 let x = Int[](count: n, repeatedValue: 1) for i in 0..n { for j in 0..n { let tmp: Int = x[j] x[i] = tmp } } let y: Int[] = sort(x) let swift_stop = NSDate.timeIntervalSinceReferenceDate(); println("\(swift_stop - swift_start)s") 

PS: Mən Objective-C-də mütəxəssis deyiləm və Kakao , Objective-C və ya Swift-dən olan bütün vasitələr deyil. Mən də yazmadığım bəzi şeyləri də təklif edə bilərəm.

101
09 июня '14 в 9:30 2014-06-09 09:30 Cavab filcab tərəfindən 09 iyun '9' da 9:30 'da verildi. 2014-06-09 09:30

Mən əyləncəyə baxmaq qərarına gəldim, və mən aldığım vaxt:

 Swift 4.0.2 : 0.83s (0.74s with `-Ounchecked`) C++ (Apple LLVM 8.0.0): 0.74s 

Swift

 // Swift 4.0 code import Foundation func doTest() -> Void { let arraySize = 10000000 var randomNumbers = [UInt32]() for _ in 0..<arraySize { randomNumbers.append(arc4random_uniform(UInt32(arraySize))) } let start = Date() randomNumbers.sort() let end = Date() print(randomNumbers[0]) print("Elapsed time: \(end.timeIntervalSince(start))") } doTest() 

Nəticələr:

Swift 1.1

 xcrun swiftc --version Swift version 1.1 (swift-600.0.54.20) Target: x86_64-apple-darwin14.0.0 xcrun swiftc -O SwiftSort.swift ./SwiftSort Elapsed time: 1.02204304933548 

Swift 1.2

 xcrun swiftc --version Apple Swift version 1.2 (swift> 

Swift 2.0

 xcrun swiftc --version Apple Swift version 2.0 (swift> 

Göründüyü kimi, mən eyni -Ounchecked tərtib -Ounchecked .

Swift 3.0

 xcrun swiftc --version Apple Swift version 3.0 (swift> 

Görünür, Swift 2.0-dan Swift 3.0-a bir performans reqressiyası var idi və mən də ilk dəfə -O-Ounchecked arasındakı fərqləri görürəm.

Swift 4.0

 xcrun swiftc --version Apple Swift version 4.0.2 (swift> 

Swift 4, -O-Ounchecked arasındakı fərqi saxlayaraq performansı artırır. -O -whole-module-optimization əhəmiyyətli görünmür.

C ++

 #include <chrono> #include <iostream> #include <vector> #include <cstdint> #include <stdlib.h> using namespace std; using namespace std::chrono; int main(int argc, const char * argv[]) { const auto arraySize = 10000000; vector<uint32_t> randomNumbers; for (int i = 0; i < arraySize; ++i) { randomNumbers.emplace_back(arc4random_uniform(arraySize)); } const auto start = high_resolution_clock::now(); sort(begin(randomNumbers), end(randomNumbers)); const auto end = high_resolution_clock::now(); cout << randomNumbers[0] << "\n"; cout << "Elapsed time: " << duration_cast<duration<double>>(end - start).count() << "\n"; return 0; } 

Nəticələr:

Apple C>

 c> 

Apple C>

 c> 

Apple C>

 c> 

Apple C>

 c> 

Apple C>

 c> 

Hökumət

Bu yazı zamanı Swift sortu sürətli, lakin C ++ kimi sürətli deyil - tərtib edərkən yuxarıdakı kompilyatorlar və kitabxanalar ilə -O . -Ounchecked Swift 4.0.2 və Apple LLVM 9.0.0-da C ++ kimi sürətli görünür.

45
27 окт. cavab verilir OpenGL ES 27 oktyabr məlumat əldə edin . 2014-10-27 00:47 '14 'də 0:47 2014-10-27 00:47

The Swift Programming > :

Standart kitabxana Sifariş Function Swifts, verdiyiniz bir növbəli növün çıxışı əsasında bilinən bir növün bir sıra növünü sıralayan bir növ funksiyanı təmin edir. Sifariş başa çatdıqdan sonra, sort funksiyası elementləri düzgün sort sırası ilə köhnə kimi eyni tip və ölçülü yeni bir sıra qaytarır.

sort funksiyası iki bəyanata malikdir.

Müqayisənin yaxınlığını təyin etməyə imkan verən default reklam:

 func sort<T>(array: T[], pred: (T, T) -> Bool) -> T[] 

Və yalnız bir parametr (array) götürən və "komparatordan az istifadə etmək üçün sabit kodlu" olan ikinci bəyanat.

 func sort<T : Comparable>(array: T[]) -> T[] Example: sort( _arrayToSort_ ) { $0 > $1 } 

Mən bu xüsusiyyətə daha yaxından nəzarət edə biləcəyim üçün kodun dəyişmiş bir versiyasını oyun sahəsinə əlavə olaraq bağladığımı test etdim və 1000 ilə təyin edildikdə, bağlanma 11,000 dəfə çağırıldı.

 let n = 1000 let x = Int[](count: n, repeatedValue: 0) for i in 0..n { x[i] = random() } let y = sort(x) { $0 > $1 } 

Bu effektiv bir funksiya deyil, sıralama funksiyasının ən yaxşı tətbiqini istifadə etməyi məsləhət görürəm.

EDIT:

Mən Quicksort wikipedia səhifəsinə baxdı və bunun üçün bir Swift tətbiq yazdım. İşdə istifadə etdiyi tam proqram (oyun meydançasında)

 import Foundation func quickSort(inout array: Int[], begin: Int, end: Int) { if (begin < end) { let p = partition( begin, end) quickSort( begin, p - 1) quickSort( p + 1, end) } } func partition(inout array: Int[], left: Int, right: Int) -> Int { let numElements = right - left + 1 let pivotIndex = left + numElements / 2 let pivotValue = array[pivotIndex] swap(  var storeIndex = left for i in left..right { let a = 1 // <- Used to see how many comparisons are made if array[i] <= pivotValue { swap(  storeIndex++ } } swap(  // Move pivot to its final place return storeIndex } let n = 1000 var x = Int[](count: n, repeatedValue: 0) for i in 0..n { x[i] = Int(arc4random()) } quickSort( 0, x.count - 1) // <- Does the sorting for i in 0..n { x[i] // <- Used by the playground to display the results } 

Bunu n = 1000 ilə istifadə edərək, mən tapdım

  • quickSort () təxminən 650 dəfə çağırıldı,
  • təxminən 6,000 swap,
  • və təxminən 10.000 müqayisə var

Daxili çeşidləmə metodu (yaxud yaxın) tez bir şəkildə sıralanır və çox yavaş görünür ...

29
08 июня '14 в 3:29 2014-06-08 03:29 cavab David Skrundz tərəfindən verilir. 08 iyun '14, 3:29 2014-06-08 03:29

Xcode 7 ilə, Fast, Whole Module Optimization təmin edə bilərsiniz. Bu dərhal məhsuldarlığı artırmalıdır.

2019

16
11 июня '15 в 19:56 2015-06-11 19:56 Cavab Antoine tərəfindən 11 iyun 'da saat 19:56' da verilir. 2015-06-11 19:56

Swift Array performansının gözlənildiyi:

Swift'ı C / Objective-C ilə müqayisə etməklə öz testim yazdım. Test imtahanlarında hesablanır. Hər bir yeni namizədə sadə faktorlar tapmaq üçün əvvəlki prinsiplər bir sıra istifadə edir, o, olduqca tezdir. Buna baxmayaraq, TON serialları oxuyur və dizilərə daha az yazır.

Mən əvvəlcə Swift 1.2-ə qarşı bu testi aparıb. Layihəni yeniləməyə və Swift 2.0-a qarşı tətbiq etməyə qərar verdim.

Layihə, adi sürətli array istifadə edərək array semantics istifadə edərək Swift təhlükəli yaddaş arabellekleri istifadə arasında seçim imkanı verir.

C / Objective-C üçün, NSArrays və ya C malloced array istifadə etmək üçün seçə bilərsiniz.

Test nəticələri ən sürətli, minimal kod optimallaşdırmasına ([-0s]) və ya ən sürətli, aqressiv ([-0fast]) optimallaşdırmaya çox oxşar görünür.

C / Objective-C performansının orta sürəti yavaş olsa da, Swift 2.0 performansını kod optimallaşdırması aradan qaldıqda hələ də qorxudur.

Aşağı xətt, malloc'd C arrayına əsaslanan hesablamalar mütləq səviyyədə ən sürətli olanıdır

Təhlükəsiz tamponlarla Swift ən sürətli və minimum kod optimallaşdırma istifadə edərkən C cc malloc'd diziliyindən 1,19x - 1.20x daha uzun sürer. fərq, sürətli, təcavüzkar optimallaşdırma ilə bir qədər kiçik görünür (Swift 1.18x, 1.16x çoxdan çox görünür)

Normal Swift dizilerini istifadə edirsinizsə, C ilə fərq bir qədər böyükdür. (Swift ~ 1.22-dən 1.23-ə qədər davam edir.)

Swift DRAMATICALLY müntəzəm diziler Swift 1.2 / Xcode 6-da olduğundan daha sürətlidır. Performansları, təhlükəli yaddaş tamponları istifadə edərək, Swift'ın təhlükəli tampon dizilişlərinə çox yaxındır, əslində bu artıq dəyər deyil.

BTW, Objective-C Performansı NSArray səhvdir. Hər iki dildə öz konteynerlərinizdən istifadə etmək istəyirsinizsə, Swift daha sürətli DRAMATICALLY .

SwiftPerformanceBenchmark'da github'ta projemi kontrol edə bilərsiniz

Statistika toplusunu asanlaşdıran sadə bir istifadəçi interfeysi var.

Maraqlıdır ki, çeşidləmə Swift-də C-ə nisbətən bir qədər daha sürətli görünür, lakin bu prime-number alqoritmi Swift-də daha sürətlidır.

9
26 февр. Cavab Duncan C verildi 26 fevral. 2016-02-26 04:31 '16 saat 04:31 'da 2016-02-26 04:31

Başqaları tərəfindən göstərilən, lakin kifayət qədər səbəb olmadığı əsas problem -O3 də Swift-də heç bir şey yoxdur və bu zaman tərtib edərkən effektiv optimallaşdırılmır ( -Onone ).

Variantların adları zamanla dəyişdi, buna görə bəzi digər cavablar qurma variantları üçün bayraqları köhnəlmişdir. Doğru cari ayarları (Swift 2.2):

 -Onone // Debug - slow -O // Optimised -O -whole-module-optimization //Optimised across files 

Bütün modulun optimallaşdırılması daha yavaş bir tərtibata malikdir, lakin moduldakı faylları, yəni hər bir struktur çərçivəsində və faktiki tətbiq kodu daxilində deyil, onların arasında optimallaşdırıla bilər. Bunu hər hansı bir kritik performans üçün istifadə etməlisiniz)

Вы также можете отключить проверки безопасности еще быстрее, но со всеми утверждениями и предпосылками не просто отключены, но оптимизированы на основе их правильности. Если вы когда-либо ударили утверждение, это означает, что вы находитесь в поведении undefined. Используйте с особой осторожностью и только если вы определите, что ускорение скорости стоит для вас (путем тестирования). Если вы считаете это ценным для некоторого кода, я рекомендую разделить этот код на отдельную структуру и отключить проверку безопасности этого модуля.

6
ответ дан Joseph Lord 13 апр. '16 в 13:58 2016-04-13 13:58
 func partition(inout list : [Int], low: Int, high : Int) -> Int { let pivot = list[high] var j = low var i = j - 1 while j < high { if list[j] <= pivot{ i += 1 (list[i], list[j]) = (list[j], list[i]) } j += 1 } (list[i+1], list[high]) = (list[high], list[i+1]) return i+1 } func quikcSort(inout list : [Int] , low : Int , high : Int) { if low < high { let pIndex = partition( low: low, high: high) quikcSort( low: low, high: pIndex-1) quikcSort( low: pIndex + 1, high: high) } } var list = [7,3,15,10,0,8,2,4] quikcSort( low: 0, high: list.count-1) var list2 = [ 10, 0, 3, 9, 2, 14, 26, 27, 1, 5, 8, -1, 8 ] quikcSort( low: 0, high: list2.count-1) var list3 = [1,3,9,8,2,7,5] quikcSort( low: 0, high: list3.count-1) 

Это мой блог о Quick Sort- Github образец Quick-Sort

Вы можете взглянуть на алгоритм разбиения Lomuto в разделе Разделение списка. Написано в Swift

4
ответ дан Abo3atef 06 дек. '16 в 14:12 2016-12-06 14:12

Swift 4.1 представляет новый -Osize оптимизации -Osize .

В Swift 4.1 компилятор теперь поддерживает новый режим оптимизации, который позволяет использовать специальные оптимизации для уменьшения размера кода.

Компилятор Swift поставляется с мощными оптимизациями. При компиляции с -O компилятор пытается преобразовать код так, чтобы он выполнялся с максимальной производительностью. Однако такое улучшение производительности во время выполнения может иногда сопровождаться компромиссом увеличения размера кода. В новом режиме оптимизации -Osize пользователь имеет возможность компилировать для минимального размера кода, а не для максимальной скорости.

Чтобы включить режим оптимизации размера в командной строке, используйте -Osize вместо -O.

Дальнейшее чтение: https://swift.org/blog/osize/

1
ответ дан casillas 15 дек. '18 в 6:25 2018-12-15 06:25

Другие вопросы по меткам или Задайте вопрос