ස්විෆ්ට් බීටා කාර්ය සාධනය: අරා වර්ග කිරීම

මම ස්විෆ්ට් බීටා හි ඇල්ගොරිතමයක් ක්‍රියාත්මක කරමින් සිටියදී එහි ක්‍රියාකාරිත්වය ඉතා දුර්වල බව දුටුවෙමි. ගැඹුරට හාරා බැලීමෙන් පසු මට වැටහී ගියේ එක් බාධකයක් අරා වර්ග කිරීම තරම් සරල දෙයක් බවයි. අදාළ කොටස මෙහි ඇත:

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 ++ හි, ඒ හා සමාන මෙහෙයුමක් මගේ පරිගණකයේ 0.06s ගනී .

පයිතන්හිදී, එය 0.6s ගනී (උපක්‍රම නැත, පූර්ණ සංඛ්‍යා ලැයිස්තුවක් සඳහා y = වර්ග කළ (x) පමණි).

පහත දැක්වෙන විධානය සමඟ මම එය සම්පාදනය කරන්නේ නම් ස්විෆ්ට්හිදී 6s ගත වේ :

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

මම එය පහත දැක්වෙන විධානය සමඟ සම්පාදනය කරන්නේ නම් එය 88s තරම් කාලයක් ගතවේ :

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

Xcode හි "මුදා හැරීම" එදිරිව "නිදොස් කිරීම" සමඟ කාලය සමාන වේ.

මෙහි වැරැද්ද කුමක්ද? C ++ හා සැසඳීමේදී මට යම් කාර්ය සාධන අලාභයක් තේරුම් ගත හැකි නමුත් පිරිසිදු පයිතන් හා සසඳන විට 10 ගුණයක මන්දගාමී වීමක් නොවේ.

සංස්කරණය කරන්න: කාලගුණය වෙනස් බව දැක -O3ගැනීමට -Ofastමෙම කේතය ලකුණු පාහේ තරම් වේගයෙන් C ++ අනුවාදය ලෙස වෙයි! කෙසේ වෙතත්, -Ofastභාෂාවේ අර්ථ නිරූපණය බොහෝ වෙනස් කරයි - මගේ පරීක්ෂණයේදී, එය පූර්ණ සංඛ්‍යා පිටාර ගැලීම් සහ අරාව සුචිගත කිරීමේ පිටාර ගැලීම් සඳහා වූ චෙක්පත් අක්‍රීය කළේය . නිදසුනක් ලෙස, -Ofastපහත දැක්වෙන ස්විෆ්ට් කේතය බිඳ වැටීමකින් තොරව නිහ ly ව ක්‍රියාත්මක වේ (සහ සමහර කසළ මුද්‍රණය කරයි):

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

ඒ නිසා -Ofastඅපට අවශ්ය දේ නොවේ; ස්විෆ්ට්හි සමස්ත කරුණ නම් අප සතුව ආරක්ෂිත දැල් තිබීමයි. ඇත්ත වශයෙන්ම, ආරක්ෂිත දැල් කාර්ය සාධනය කෙරෙහි යම් බලපෑමක් ඇති කරයි, නමුත් ඒවා වැඩසටහන් 100 ගුණයකින් මන්දගාමී නොකළ යුතුය. ජාවා දැනටමත් අරාව මායිම් පරීක්ෂා කර ඇති බව මතක තබා ගන්න, සාමාන්‍ය අවස්ථාවන්හිදී මන්දගාමී වීම 2 ට වඩා අඩු සාධකයකි. තවද ක්ලැන්ග් සහ ජීසීසී හි -ftrapvපූර්ණ සංඛ්‍යා පිටාර ගැලීම් පරීක්ෂා කිරීම සඳහා අපට ලැබී ඇති අතර එය එතරම් මන්දගාමී නොවේ.

එබැවින් ප්‍රශ්නය: ආරක්ෂිත දැල් අහිමි නොවී ස්විෆ්ට් හි සාධාරණ කාර්ය සාධනයක් ලබා ගන්නේ කෙසේද?

2 වන සංස්කරණය: මම තවත් මිණුම් සලකුණු කිහිපයක් කළෙමි

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

(මෙහි xor මෙහෙයුම ඇත්තේ එකලස් කිරීමේ කේතයේ අදාළ ලූපය වඩාත් පහසුවෙන් සොයාගත හැකි වන පරිදිය. මම පහසුවෙන් හඳුනාගත හැකි මෙහෙයුමක් තෝරා ගැනීමට උත්සාහ කළෙමි. පූර්ණ සංඛ්‍යා පිටාර ගැලීමට.)

නැවතත්, -O3සහ අතර කාර්ය සාධනයෙහි විශාල වෙනසක් සිදුවිය -Ofast. ඒ නිසා මම එකලස් කිරීමේ කේතය දෙස බැලුවෙමි:

• සමග -Ofastමම බලාපොරොත්තු වන්නේ කුමක්ද එච්චරමයි ලබා ගන්න. අදාළ කොටස යන්ත්‍ර භාෂා උපදෙස් 5 ක් සහිත ලූපයකි.

• සමග -O3මම මගේ වියරු පරිකල්පනය ඔබ්බට හැකි දෙයක් ලබා ගන්න. අභ්‍යන්තර ලූප එකලස් කිරීමේ කේතයේ පේළි 88 ක් විහිදේ. මම ඒ සියල්ල තේරුම් ගැනීමට උත්සාහ නොකළ නමුත් වඩාත්ම සැක සහිත කොටස් වන්නේ "callq _swift_retain" හි ආයාචනා 13 ක් සහ "callq _swift_release" හි තවත් ආයාචනා 13 කි. එනම්, අභ්‍යන්තර පුඩුවේ සබ්ට්‍රවුටින් ඇමතුම් 26 ක් !

3 වන සංස්කරණය: අදහස් දැක්වීමේදී, ෆෙරුසියෝ විසින් ගොඩනඟන ලද කාර්යයන් (උදා. වර්ග කිරීම) මත රඳා නොසිටින අර්ථයෙන් සාධාරණ මිණුම් සලකුණු ඉල්ලා සිටියේය. මම හිතන්නේ පහත වැඩසටහන තරමක් හොඳ උදාහරණයක්:

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

අංක ගණිතයක් නොමැත, එබැවින් පූර්ණ සංඛ්‍යා පිටාර ගැලීම් ගැන අපට කරදර විය යුතු නැත. අප කරන එකම දෙය වන්නේ අරාව යොමු කිරීම් ගොඩක් පමණි. ප්‍රති results ල මෙහි ඇත - ස්විෆ්ට්-ඕ 3 -ෆාස්ට් හා සසඳන විට 500 කට ආසන්න සාධකයකින් අහිමි වේ:

• C ++ -O3: 0.05 s
• C ++ -O0: 0.4 s
• ජාවා: 0.2 s
• PyPy සමඟ පයිතන්: 0.5 s
• පයිතන්: 12 ස
• ස්විෆ්ට් -ෆාස්ට්: 0.05 s
• ස්විෆ්ට්-ඕ 3: 23 සෙ
• ස්විෆ්ට් -O0: 443 s

(සම්පාදකයාට අර්ථ විරහිත ලූප මුළුමනින්ම ප්‍රශස්තිකරණය කළ හැකි යැයි ඔබ සිතන්නේ නම්, ඔබට එය උදා. ලෙස වෙනස් කළ හැකි අතර x[i] ^= x[j]ප්‍රතිදානය කරන මුද්‍රණ ප්‍රකාශයක් එක් කරන්න x[0]. මෙය කිසිවක් වෙනස් නොකරයි; වේලාවන් ඉතා සමාන වනු ඇත.)

ඔව්, මෙහි පයිතන් ක්‍රියාත්මක කිරීම මෝඩ පිරිසිදු පයිතන් ක්‍රියාත්මක කිරීමක් වන අතර එය අඟල් ලැයිස්තුවක් සහ ලූප සඳහා කූඩු කර ඇත. එය භාවිතයට නොගත් ස්විෆ්ට වඩා මන්දගාමී විය යුතුය . ස්විෆ්ට් සහ අරා සුචිගත කිරීම් සමඟ යමක් බරපතල ලෙස බිඳී ඇති බව පෙනේ.

සංස්කරණය 4: මෙම ගැටළු (මෙන්ම වෙනත් කාර්ය සාධන ගැටළු) Xcode 6 බීටා 5 හි සවි කර ඇති බව පෙනේ.

වර්ග කිරීම සඳහා, මට දැන් පහත වේලාවන් ඇත:

• clang ++ -O3: 0.06 s
• swiftc -Ofast: 0.1 s
• swiftc -O: 0.1 s
• swiftc: 4 s

කැදැලි වළළු සඳහා:

• clang ++ -O3: 0.06 s
• swiftc -Ofast: 0.3 s
• swiftc -O: 0.4 s
• swiftc: 540 s

අනාරක්ෂිත -Ofast(අකා -Ounchecked) භාවිතා කිරීමට තවදුරටත් හේතුවක් නොමැති බව පෙනේ ; සරල ලෙස -Oසමාන කේතයක් නිපදවයි.

tl; dr ස්විෆ්ට් 1.0 පෙරනිමි මුදාහැරීම් ප්‍රශස්තිකරණ මට්ටම [-O] භාවිතා කරමින් මෙම මිණුම් ලකුණ අනුව සී තරම් වේගවත් වේ.

ස්විෆ්ට් බීටා හි ස්ථානගතව ඇති ක්වික්සෝර්ට් මෙන්න:

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(&a, start, r + 1)
    quicksort_swift(&a, r + 1, end)
}

C හි ද එයම ය:

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);
}

දෙකම වැඩ කරයි:

var a_swift:CInt[] = [0,5,2,8,1234,-1,2]
var a_c:CInt[] = [0,5,2,8,1234,-1,2]

quicksort_swift(&a_swift, 0, a_swift.count)
quicksort_c(&a_c, CInt(a_c.count))

// [-1, 0, 2, 2, 5, 8, 1234]
// [-1, 0, 2, 2, 5, 8, 1234]

දෙකම එකම වැඩසටහනකින් ලියා ඇත.

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(&x_swift, 0, x_swift.count)
let swift_stop:UInt64 = mach_absolute_time();

let c_start:UInt64 = mach_absolute_time();
quicksort_c(&x_c, CInt(x_c.count))
let c_stop:UInt64 = mach_absolute_time();

මෙය නිරපේක්ෂ වේලාවන් තත්පර බවට පරිවර්තනය කරයි:

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(&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;
}

සම්පාදකයාගේ ප්‍රශස්තිකරණ මට්ටම්වල සාරාංශයක් මෙන්න:

[-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 සඳහා [-Onone] සමඟ තත්පර කිහිපයකින් කාලය :

Swift:            0.895296452
C:                0.001223848

N = 10_000 සඳහා ස්විෆ්ට් හි බිල්ඩින් වර්ග කිරීම මෙන්න () :

Swift_builtin:    0.77865783

N = 10_000 සඳහා මෙන්න [-O] :

Swift:            0.045478346
C:                0.000784666
Swift_builtin:    0.032513488

ඔබට පෙනෙන පරිදි, ස්විෆ්ට් හි කාර්ය සාධනය 20 කින් වැඩි විය.

අනුව mweathers 'පිළිතුර , සැකසීම [-Ofast] සඳහා මෙම වාර නිසා, සැබෑ වෙනසක් n = 10_000 :

Swift:            0.000706745
C:                0.000742374
Swift_builtin:    0.000603576

සහ n = 1_000_000 සඳහා :

Swift:            0.107111846
C:                0.114957179
Swift_sort:       0.092688548

සංසන්දනය සඳහා, මෙය n = 1_000_000 සඳහා [-Onone] සමඟ වේ :

Swift:            142.659763258
C:                0.162065333
Swift_sort:       114.095478272

එබැවින් ප්‍රශස්තිකරණයන් නොමැති ස්විෆ්ට් මෙම මිණුම් ලකුණෙහි සී ට වඩා 1000 ගුණයකින් මන්දගාමී විය. අනෙක් අතට, සම්පාදකයින් දෙදෙනාම [-Ofast] ලෙස සකසා ඇති අතර ස්විෆ්ට් ඇත්ත වශයෙන්ම අවම වශයෙන් මෙන්ම සී ට වඩා තරමක් හොඳ නොවේ නම් සිදු කරයි.

[-Ofast] භාෂාවේ අර්ථ නිරූපණය වෙනස් කරන අතර එය අනාරක්ෂිත විය හැකි බව පෙන්වා දී ඇත. Xcode 5.0 නිකුතු සටහන් වල ඇපල් පවසන්නේ මෙයයි:

LLVM හි ඇති නව ප්‍රශස්තිකරණ මට්ටමක් - වේගවත්, ආක්‍රමණශීලී ප්‍රශස්තිකරණයන් සක්‍රීය කරයි. බොහෝ කේත සඳහා ආරක්ෂිත වන පාවෙන ලක්ෂ්‍ය මෙහෙයුම් සඳහා බොහෝ සාම්ප්‍රදායික සීමා කිරීම් ලිහිල් කරයි. එය සම්පාදකයාගෙන් සැලකිය යුතු ඉහළ කාර්ය සාධනයක් ලබා ගත හැකිය.

ඔවුන් සියල්ලෝම එය වෙනුවෙන් පෙනී සිටිති. එය wise ානවන්තද නැද්ද යන්න මට පැවසිය නොහැක, නමුත් මට කිව හැකි දෙයින් [-Ofast] නිකුතුවකදී භාවිතා කිරීම ප්‍රමාණවත් යැයි පෙනේ නම් ඔබ ඉහළ නිරවද්‍යතාවයකින් යුත් පාවෙන ලක්ෂ්‍ය ගණිතයක් නොකරන්නේ නම් සහ පූර්ණ සංඛ්‍යාවක් නොමැති බව ඔබට විශ්වාසද? ඔබේ වැඩසටහන තුළ අරාව පිටාර ගැලීම කළ හැකිය. ඔබට ඉහළ කාර්ය සාධනයක් සහ පිටාර ගැලීම් / නිරවද්‍ය ගණිතයක් අවශ්‍ය නම් දැන් වෙනත් භාෂාවක් තෝරන්න.

බීටා 3 යාවත්කාලීන කිරීම:

[-O] සමඟ n = 10_000 :

Swift:            0.019697268
C:                0.000718064
Swift_sort:       0.002094721

පොදුවේ ස්විෆ්ට් ටිකක් වේගවත් වන අතර ස්විෆ්ට් හි බිල්ට් වර්ග කිරීම සැලකිය යුතු ලෙස වෙනස් වී ඇති බව පෙනේ.

අවසාන යාවත්කාලීන කිරීම:

[-නො] :

Swift:   0.678056695
C:       0.000973914

[-O] :

Swift:   0.001158492
C:       0.001192406

[පරීක්ෂා කර ඇත] :

Swift:   0.000827764
C:       0.001078914

ටීඑල්; ඩීආර් : ඔව්, එකම ස්විෆ්ට් භාෂාව ක්‍රියාත්මක කිරීම මන්දගාමීයි, දැන් . ඔබට වේගවත්, සංඛ්‍යාත්මක (සහ වෙනත් වර්ගවල කේත, අනුමාන වශයෙන්) කේතයක් අවශ්‍ය නම්, තවත් එකක් සමඟ යන්න. අනාගතයේදී, ඔබ ඔබේ තේරීම නැවත ඇගයීමට ලක් කළ යුතුය. ඉහළ මට්ටමක ලියා ඇති බොහෝ යෙදුම් කේත සඳහා එය හොඳ විය හැකිය.

මම සිල් පවාරණය හා LLVM IR දී දුටු දේ කරනවා සිට, එය අත හා ක්රියාත්මක කළ හැකි වන නිවේදන, ඔවුන් ඉවත් කිරීම සඳහා ප්රතිස්තිකරණය රෑනක් අවශ්ය වගේ Clang (අරමුණ-C භාෂාව සඳහා), නමුත් ඔවුන් තවමත් වරායෙහි නැත. මා සමඟ යන න්‍යාය එයයි (දැනට… ක්ලැන්ග් ඒ ගැන යමක් කරන බව මට තවම තහවුරු කළ යුතුව ඇත), මන්ද මෙම ප්‍රශ්නයේ අවසාන පරීක්ෂණ නඩුවේ පැතිකඩක් ධාවනය කිරීමෙන් මෙම “ලස්සන” ප්‍රති result ලය ලැබේ:

තවත් බොහෝ අය පැවසූ පරිදි, -Ofastමුළුමනින්ම අනාරක්‍ෂිත වන අතර භාෂා අර්ථ නිරූපණය වෙනස් කරයි. මට නම් එය “ඔබ එය භාවිතා කිරීමට යන්නේ නම් වෙනත් භාෂාවක් භාවිතා කරන්න” යන අදියරෙහි ය. එම තේරීම වෙනස් වුවහොත් මම පසුව එය නැවත ඇගයීමට ලක් කරමි.

-O3අප රෑනක් ලැබෙන swift_retainහා swift_releaseඇමතුම් අවංකව, ඔවුන් මෙම උදාහරණය සඳහා තිබිය යුතු වැනි බලන්න එපා, ඒ. අරාව පිළිබඳ බොහෝ තොරතුරු දන්නා නිසාත්, (අවම වශයෙන්) ඒ පිළිබඳව ප්‍රබල සඳහනක් ඇති බව දන්නා නිසාත්, ප්‍රශස්තකරණය ඔවුන්ගෙන් බොහෝමයක් AFAICT ඉවත් කර තිබිය යුතුය.

වස්තූන් මුදා හැරිය හැකි කාර්යයන් පවා නොකියන විට එය වැඩි රඳවා ගැනීමක් නොකළ යුතුය. අරාව සාදන්නෙකුට ඉල්ලූ දෙයට වඩා කුඩා අරාවක් ආපසු ලබා දිය හැකි යැයි මම නොසිතමි, එයින් අදහස් කරන්නේ විමෝචනය කරන ලද චෙක්පත් බොහොමයක් නිෂ් .ල බවයි. නිඛිලය කිසි විටෙකත් 10k ට වඩා වැඩි නොවන බව ද එය දනී, එබැවින් පිටාර ගැලීම් පරීක්ෂා කළ හැකිය ප්‍රශස්තිකරණය හැකිය ( -Ofastඅමුතුකම නිසා නොව, භාෂාවේ අර්ථ නිරූපණය නිසා) (වෙන කිසිවක් වෙනස් නොවේ, එයට ප්‍රවේශ විය නොහැක, සහ 10k දක්වා එකතු කිරීම වර්ගය සඳහා ආරක්ෂිතයි Int).

සම්පාදකයාට අරාව හෝ අරාව මූලද්‍රව්‍ය අගුළු ඇරීමට නොහැකි විය හැක sort() වන බැවින් එය බාහිර ශ්‍රිතයක් වන අතර එය අපේක්ෂා කරන තර්ක ලබා ගත යුතුය. මෙමඟින් අපට Intඅගයන් වක්‍රව භාවිතා කිරීමට සිදුවනු ඇත, එමඟින් එය ටිකක් මන්දගාමී වේ. නම්, මෙම වෙනස් විය හැකි sort()Generic බලපත්රය යටතේ අවසර ලබා ඇත කාර්යය (මිස බහු-ක්රමය ආකාරයෙන්) සම්පාදකවරයා ලබාගත හැකි විය හා inlined වී.

මෙය ඉතා අළුත් (ප්‍රසිද්ධියේ) භාෂාවක් වන අතර, එය ස්විෆ්ට් භාෂාව සමඟ ප්‍රතිපෝෂණ ඉල්ලා සිටින පුද්ගලයින් (දැඩි ලෙස) සම්බන්ධ වී ඇති අතර ඔවුන් සියල්ලන්ම පවසන්නේ භාෂාව අවසන් වී නැති බවත් කැමති බවත් වෙනස් කරන්න.

භාවිතා කළ කේතය:

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: මම Objective-C හෝ කොකෝවා , Objective-C, හෝ ස්විෆ්ට් ධාවන වේලාවන්හි ඇති සියලුම පහසුකම් පිළිබඳ විශේෂ expert යෙක් නොවේ. මම ලියන්නේ නැති සමහර දේවල් මම උපකල්පනය කරනවා විය හැකිය.

විනෝදය සඳහා මෙය බැලීමට මම තීරණය කළෙමි, මට ලැබෙන වේලාවන් මෙන්න:

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

ස්විෆ්ට්

// 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()

ප්රතිපල:

ස්විෆ්ට් 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

ස්විෆ්ට් 1.2

xcrun swiftc --version
Apple Swift version 1.2 (swiftlang-602.0.49.6 clang-602.0.49)
Target: x86_64-apple-darwin14.3.0

xcrun -sdk macosx swiftc -O SwiftSort.swift
./SwiftSort     
Elapsed time: 0.738763988018036

ස්විෆ්ට් 2.0

xcrun swiftc --version
Apple Swift version 2.0 (swiftlang-700.0.59 clang-700.0.72)
Target: x86_64-apple-darwin15.0.0

xcrun -sdk macosx swiftc -O SwiftSort.swift
./SwiftSort     
Elapsed time: 0.767306983470917

මා සම්පාදනය කරන්නේ නම් එය එකම කාර්ය සාධනයක් බව පෙනේ -Ounchecked.

ස්විෆ්ට් 3.0

xcrun swiftc --version
Apple Swift version 3.0 (swiftlang-800.0.46.2 clang-800.0.38)
Target: x86_64-apple-macosx10.9

xcrun -sdk macosx swiftc -O SwiftSort.swift
./SwiftSort     
Elapsed time: 0.939633965492249

xcrun -sdk macosx swiftc -Ounchecked SwiftSort.swift
./SwiftSort     
Elapsed time: 0.866258025169373

ස්විෆ්ට් 2.0 සිට ස්විෆ්ට් 3.0 දක්වා කාර්ය සාධන ප්‍රතිගාමී බවක් පෙනෙන්නට ඇති අතර , පළමු වරට -Oසහ අතර වෙනසක් ද මම දකිමි -Ounchecked.

ස්විෆ්ට් 4.0

xcrun swiftc --version
Apple Swift version 4.0.2 (swiftlang-900.0.69.2 clang-900.0.38)
Target: x86_64-apple-macosx10.9

xcrun -sdk macosx swiftc -O SwiftSort.swift
./SwiftSort     
Elapsed time: 0.834299981594086

xcrun -sdk macosx swiftc -Ounchecked SwiftSort.swift
./SwiftSort     
Elapsed time: 0.742045998573303

-Oසහ අතර පරතරයක් පවත්වා ගනිමින් ස්විෆ්ට් 4 නැවතත් කාර්ය සාධනය වැඩි දියුණු කරයි -Ounchecked. -O -whole-module-optimizationවෙනසක් ඇති බවක් නොපෙනුණි.

සී ++

#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;
}

ප්රතිපල:

ඇපල් ක්ලැන්ග් 6.0

clang++ --version
Apple LLVM version 6.0 (clang-600.0.54) (based on LLVM 3.5svn)
Target: x86_64-apple-darwin14.0.0
Thread model: posix

clang++ -O3 -std=c++11 CppSort.cpp -o CppSort
./CppSort     
Elapsed time: 0.688969

ඇපල් ක්ලැන්ග් 6.1.0

clang++ --version
Apple LLVM version 6.1.0 (clang-602.0.49) (based on LLVM 3.6.0svn)
Target: x86_64-apple-darwin14.3.0
Thread model: posix

clang++ -O3 -std=c++11 CppSort.cpp -o CppSort
./CppSort     
Elapsed time: 0.670652

ඇපල් ක්ලැන්ග් 7.0.0

clang++ --version
Apple LLVM version 7.0.0 (clang-700.0.72)
Target: x86_64-apple-darwin15.0.0
Thread model: posix

clang++ -O3 -std=c++11 CppSort.cpp -o CppSort
./CppSort     
Elapsed time: 0.690152

ඇපල් ක්ලැන්ග් 8.0.0

clang++ --version
Apple LLVM version 8.0.0 (clang-800.0.38)
Target: x86_64-apple-darwin15.6.0
Thread model: posix

clang++ -O3 -std=c++11 CppSort.cpp -o CppSort
./CppSort     
Elapsed time: 0.68253

ඇපල් ක්ලැන්ග් 9.0.0

clang++ --version
Apple LLVM version 9.0.0 (clang-900.0.38)
Target: x86_64-apple-darwin16.7.0
Thread model: posix

clang++ -O3 -std=c++11 CppSort.cpp -o CppSort
./CppSort     
Elapsed time: 0.736784

තීන්දුව

මෙම ලිවීමේ වේලාව වන විට, ස්විෆ්ට් වර්ග කිරීම වේගවත් ය, නමුත් -Oඉහත සම්පාදකයින් සහ පුස්තකාල සමඟ සම්පාදනය කරන විට සී ++ වර්ග කිරීම තරම් වේගවත් නොවේ . සමඟ -Ounchecked, එය ස්විෆ්ට් 4.0.2 සහ ඇපල් එල්එල්වීඑම් 9.0.0 හි සී ++ තරම් වේගවත් බව පෙනේ.

සිට The Swift Programming Language:

වර්ග කිරීමේ ශ්‍රිතය ස්විෆ්ට්හි සම්මත පුස්තකාලය වර්ග කිරීම නම් ශ්‍රිතයක් සපයයි, එය ඔබ සපයන වර්ග කිරීමේ වසා දැමීමේ ප්‍රතිදානය මත පදනම්ව දන්නා වර්ගයක අගයන් වර්ග කරයි. එය වර්ග කිරීමේ ක්‍රියාවලිය සම්පුර්ණ කළ පසු, වර්ග කිරීමේ ශ්‍රිතය පැරණි වර්ගයට සමාන ප්‍රමාණයෙන් සහ ප්‍රමාණයෙන් නව පෙළක් ලබා දෙයි.

මෙම sortකාර්යය ප්රකාශ දෙකක් ඇත.

සංසන්දනාත්මක වසා දැමීමක් නියම කිරීමට ඔබට ඉඩ සලසන පෙරනිමි ප්‍රකාශනය:

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

දෙවන ප්‍රකාශනය තනි පරාමිතියක් (අරාව) පමණක් ගන්නා අතර එය "සංසන්දකයාට වඩා අඩු ප්‍රමාණයක් භාවිතා කිරීමට දැඩි කේතගත කර ඇත."

func sort<T : Comparable>(array: T[]) -> T[]

Example:
sort( _arrayToSort_ ) { $0 > $1 }

ඔබගේ කේතයේ නවීකරණය කරන ලද අනුවාදයක් ක්‍රීඩා පිටියකදී පරීක්ෂා කර ඇති අතර එමඟින් වසා දැමීම එකතු කර ඇති අතර එමඟින් ක්‍රියාකාරීත්වය මඳක් සමීපව නිරීක්ෂණය කිරීමට මට හැකි විය.

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

එය කාර්යක්ෂම ශ්‍රිතයක් නොවේ, වඩා හොඳ වර්ග කිරීමේ ශ්‍රිතයක් භාවිතා කිරීම නිර්දේශ කරමි.

සංස්කරණය කරන්න:

මම ක්වික්සෝර්ට් විකිපීඩියා පිටුව දෙස බලා ඒ සඳහා ස්විෆ්ට් ක්‍රියාත්මක කිරීමක් ලිවීය. මෙන්න මම භාවිතා කළ සම්පූර්ණ වැඩසටහන (ක්‍රීඩා පිටියක)

import Foundation

func quickSort(inout array: Int[], begin: Int, end: Int) {
    if (begin < end) {
        let p = partition(&array, begin, end)
        quickSort(&array, begin, p - 1)
        quickSort(&array, 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(&array[pivotIndex], &array[right])
    var storeIndex = left
    for i in left..right {
        let a = 1 // <- Used to see how many comparisons are made
        if array[i] <= pivotValue {
            swap(&array[i], &array[storeIndex])
            storeIndex++
        }
    }
    swap(&array[storeIndex], &array[right]) // 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(&x, 0, x.count - 1) // <- Does the sorting

for i in 0..n {
    x[i] // <- Used by the playground to display the results
}

N = 1000 සමඟ මෙය භාවිතා කිරීමෙන් මට එය හමු විය

1. quickSort () 650 වාරයක් පමණ කතා කර ඇත,
2. හුවමාරු 6000 ක් පමණ සාදන ලදී,
3. සැසඳීම් 10,000 ක් පමණ ඇත

බිල්ට් වර්ග කිරීමේ ක්‍රමය ඉක්මන් වර්ග කිරීම (හෝ ආසන්න) බව පෙනේ, එය සැබවින්ම මන්දගාමී වේ ...

Xcode 7 වන විට ඔබට සක්‍රිය කළ හැකිය Fast, Whole Module Optimization. මෙය ඔබගේ කාර්ය සාධනය වහාම වැඩි කළ යුතුය.

ස්විෆ්ට් අරා කාර්ය සාධනය නැවත සලකා බලන ලදි:

මම ස්විෆ්ට් සී / පරමාර්ථ-සී සමඟ සංසන්දනය කරමින් මගේම මිණුම් ලකුණක් ලිව්වෙමි. මගේ මිණුම් ලකුණ ප්‍රධාන සංඛ්‍යා ගණනය කරයි. එක් එක් නව අපේක්ෂකයාගේ මූලික සාධක සෙවීම සඳහා එය පෙර ප්‍රාථමික සංඛ්‍යා පෙළ භාවිතා කරයි, එබැවින් එය තරමක් වේගවත් ය. කෙසේ වෙතත්, එය ටොන් ගණනක් අරාව කියවීම සහ අරා වලට ලිවීම අඩු කරයි.

මම මුලින් කළේ ස්විෆ්ට් 1.2 ට එරෙහිව මෙම මිණුම් ලකුණයි. ව්‍යාපෘතිය යාවත්කාලීන කර ස්විෆ්ට් 2.0 ට එරෙහිව ක්‍රියාත්මක කිරීමට මම තීරණය කළෙමි.

සාමාන්‍ය ස්විෆ්ට් අරා භාවිතා කිරීම සහ අරා සෙමන්ටික්ස් භාවිතා කරමින් ස්විෆ්ට් අනාරක්ෂිත මතක බෆර භාවිතා කිරීම අතර තෝරා ගැනීමට ව්‍යාපෘතිය ඔබට ඉඩ දෙයි.

C / Objective-C සඳහා, ඔබට NSArrays හෝ C malloc'ed අරා භාවිතා කිරීමට තෝරා ගත හැකිය.

පරීක්ෂණ ප්‍රති results ල වේගවත්ම, කුඩාම කේත ප්‍රශස්තිකරණය ([-0s]) හෝ වේගවත්ම, ආක්‍රමණශීලී ([-0fast]) ප්‍රශස්තිකරණය සමඟ බෙහෙවින් සමාන බව පෙනේ.

කේත ප්‍රශස්තිකරණය අක්‍රිය කිරීමත් සමඟ ස්විෆ්ට් 2.0 කාර්ය සාධනය තවමත් භයානක වන අතර සී / පරමාර්ථ-සී කාර්ය සාධනය මධ්‍යස්ථව මන්දගාමී වේ.

අවසාන කරුණ නම්, C malloc'd array මත පදනම් වූ ගණනය කිරීම් වේගවත්ම, මධ්‍යස්ථ ආන්තිකයකින් වීමයි

අනාරක්ෂිත බෆර සහිත ස්විෆ්ට් වේගවත්ම හා කුඩාම කේත ප්‍රශස්තිකරණය භාවිතා කරන විට C malloc'd අරා වලට වඩා 1.19X - 1.20X පමණ කාලයක් ගතවේ. වේගවත්, ආක්‍රමණශීලී ප්‍රශස්තිකරණය සමඟ වෙනස තරමක් අඩු බව පෙනේ (ස්විෆ්ට් සී ට වඩා 1.18x සිට 1.16x දක්වා වැඩි වේ.

ඔබ සාමාන්‍ය ස්විෆ්ට් අරා භාවිතා කරන්නේ නම්, සී සමඟ වෙනස තරමක් වැඩි ය. (ස්විෆ්ට් සඳහා ඩොලර් 1.22 සිට 1.23 දක්වා කාලයක් ගතවේ.)

නිත්‍ය ස්විෆ්ට් අරා DRAMATICALLYස්විෆ්ට් 1.2 / එක්ස් කේත 6 ට වඩා වේගවත් ය. ඒවායේ ක්‍රියාකාරිත්වය ස්විෆ්ට් අනාරක්ෂිත බෆර් පාදක අරා වලට ඉතා ආසන්න බැවින් අනාරක්ෂිත මතක බෆර භාවිතා කිරීම කරදරයට වඩා වටින බවක් නොපෙනේ, එය විශාල ය.

BTW, Objective-C NSArray කාර්ය සාධනය ගඳයි. ඔබ භාෂා දෙකෙන්ම දේශීය බහාලුම් වස්තු භාවිතා කිරීමට යන්නේ නම්, ස්විෆ්ට් නාටකාකාර ලෙස වේගවත් වේ.

ඔබට ස්විෆ්ට්පර්ෆෝමන්ස් බෙන්ච්මාර්ක් හි ගිතුබ් පිළිබඳ මගේ ව්‍යාපෘතිය පරීක්ෂා කළ හැකිය

එය සරල UI එකක් ඇති අතර එමඟින් සංඛ්‍යාලේඛන එකතු කිරීම පහසු කරයි.

වර්ග කිරීම දැන් සී ට වඩා ස්විෆ්ට්හි තරමක් වේගවත් බව පෙනේ, නමුත් මෙම ප්‍රයිම් අංක ඇල්ගොරිතම තවමත් ස්විෆ්ට් හි වේගවත් ය.

අනෙක් අය විසින් සඳහන් කර ඇති නමුත් ප්‍රමාණවත් ලෙස නොකියන ප්‍රධාන ගැටළුව නම් -O3ස්විෆ්ට් හි කිසිසේත් කිසිවක් නොකිරීමයි (සහ කිසි විටෙකත් නැත) එබැවින් එය සම්පාදනය කරන විට එය effectively ලදායී ලෙස ප්‍රශස්තිකරණය නොකෙරේ ( -Onone).

කාලයත් සමඟ විකල්ප නම් වෙනස් වී ඇති බැවින් තවත් සමහර පිළිතුරු සඳහා යල්පැනගිය කොඩි ඇත. නිවැරදි වත්මන් විකල්ප (ස්විෆ්ට් 2.2):

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

සම්පුර්ණ මොඩියුල ප්‍රශස්තිකරණය මන්දගාමී සම්පාදනයක් ඇති නමුත් මොඩියුලය තුළ ඇති ගොනු හරහා ප්‍රශස්තිකරණය කළ හැකිය, එනම් එක් එක් රාමුව තුළ සහ සත්‍ය යෙදුම් කේතය තුළ මිස ඒවා අතර නොවේ. කාර්ය සාධන විවේචනාත්මක ඕනෑම දෙයක් සඳහා ඔබ මෙය භාවිතා කළ යුතුය)

ඔබට ඊටත් වඩා වේගයකින් ආරක්‍ෂිත චෙක්පත් අක්‍රිය කළ හැකි නමුත් සියලු ප්‍රකාශ සහ පූර්ව කොන්දේසි සමඟ අක්‍රීය නොව ඒවා නිවැරදි බව මත පදනම්ව ප්‍රශස්තිකරණය කළ හැකිය. ඔබ කවදා හෝ ප්‍රකාශයකට පහර දුන්නොත් එයින් අදහස් වන්නේ ඔබ නිර්වචනය නොකළ හැසිරීමකට යොමු වී ඇති බවයි. අතිශයින්ම පරිස්සමින් භාවිතා කරන්න, වේගය වැඩි කිරීම ඔබට වටින බව ඔබ තීරණය කළහොත් පමණි (පරීක්ෂා කිරීමෙන්). ඔබ යම් කේතයක් සඳහා එය වටිනවා නම්, එම කේතය වෙනම රාමුවකට වෙන් කොට එම මොඩියුලය සඳහා වන ආරක්ෂක චෙක්පත් අක්‍රීය කිරීම පමණක් නිර්දේශ කරමි.

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(&list, low: low, high: high)
        quikcSort(&list, low: low, high: pIndex-1)
        quikcSort(&list, low: pIndex + 1, high: high)
    }
}

var list = [7,3,15,10,0,8,2,4]
quikcSort(&list, low: 0, high: list.count-1)

var list2 = [ 10, 0, 3, 9, 2, 14, 26, 27, 1, 5, 8, -1, 8 ]
quikcSort(&list2, low: 0, high: list2.count-1)

var list3 = [1,3,9,8,2,7,5]
quikcSort(&list3, low: 0, high: list3.count-1) 

ඉක්මන් වර්ග කිරීම- ගිතුබ් නියැදිය ඉක්මන්-වර්ග කිරීම පිළිබඳ මගේ බ්ලොග් අඩවිය මෙයයි

ලැයිස්තුව කොටස් කිරීමේ දී ඔබට ලොමුටෝගේ කොටස් කිරීමේ ඇල්ගොරිතම දෙස බැලිය හැකිය. ස්විෆ්ට් හි ලියා ඇත.

ස්විෆ්ට් 4.1 නව -Osizeප්‍රශස්තිකරණ මාදිලිය හඳුන්වා දෙයි .

ස්විෆ්ට් 4.1 හි, සම්පාදකයා දැන් නව ප්‍රශස්තිකරණ මාදිලියකට සහය දක්වයි, එමඟින් කේත ප්‍රමාණය අඩු කිරීමට කැපවූ ප්‍රශස්තිකරණයන් සක්‍රීය කරයි.

ස්විෆ්ට් සම්පාදකයා බලගතු ප්‍රශස්තිකරණයන් සමඟ පැමිණේ. -O සමඟ සම්පාදනය කිරීමේදී සම්පාදකයා කේතය පරිවර්තනය කිරීමට උත්සාහ කරන අතර එමඟින් එය උපරිම ක්‍රියාකාරීත්වයකින් ක්‍රියාත්මක වේ. කෙසේ වෙතත්, ධාවන කාල ක්‍රියාකාරිත්වයේ මෙම වැඩිදියුණු කිරීම සමහර විට කේත ප්‍රමාණයේ වෙළඳාමක් සමඟ පැමිණිය හැකිය. නව-ඕසයිස් ප්‍රශස්තිකරණ මාදිලිය සමඟ පරිශීලකයාට උපරිම වේගයට වඩා අවම කේත ප්‍රමාණයක් සම්පාදනය කිරීමේ තේරීම ඇත.

විධාන රේඛාවේ ප්‍රමාණ ප්‍රශස්තිකරණ මාදිලිය සක්‍රීය කිරීමට, -O වෙනුවට -Osize භාවිතා කරන්න.

වැඩිදුර කියවීම: https://swift.org/blog/osize/