সুইফ্ট বিটা পারফরম্যান্স: অ্যারে বাছাই করা

Question

আমি সুইফ্ট বিটাতে একটি অ্যালগরিদম বাস্তবায়ন করছিলাম এবং লক্ষ্য করেছি যে পারফরম্যান্সটি খুব খারাপ। আরও গভীর খননের পরে আমি বুঝতে পারি যে বাধাগুলির মধ্যে একটি হ'ল অ্যারে বাছাইয়ের মতো সহজ কিছু। সম্পর্কিত অংশটি এখানে:

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

সি ++ তে, একই ধরণের অপারেশনটি 0.06s লাগে আমার কম্পিউটারে ।

পাইথনে এটি লাগে 0.6 (কোন ট্রিক্স নয়, পূর্ণসংখ্যার তালিকার জন্য কেবল y = সাজানো (এক্স))।

আমি নিম্নলিখিত কমান্ডটি দিয়ে সংকলন করলে সুইফটে এটি 6s লাগে :

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

আমি নিম্নলিখিত কমান্ডটি দিয়ে এটি সঙ্কলন করলে 88s এর মতো সময় লাগে :

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

"রিলিজ" বনাম "ডিবাগ" বিল্ডগুলির সাথে এক্সকোডের সময়গুলি একই রকম।

এখানে কি ভুল? আমি সি ++ এর সাথে তুলনা করে কিছু কার্যকারিতা ক্ষতি বুঝতে পেরেছিলাম, তবে খাঁটি পাইথনের তুলনায় 10-গুণ গতি কমছে না।

---

সম্পাদনা: আবহাওয়া লক্ষ্য করেছে যে এই কোডটি পরিবর্তন -O3করা -Ofastসি -+ সংস্করণ হিসাবে প্রায় দ্রুত চালায়! যাইহোক, -Ofastভাষার শব্দার্থবিজ্ঞানকে অনেক পরিবর্তন করে - আমার পরীক্ষায় এটি পূর্ণসংখ্যার ওভারফ্লো এবং অ্যারের সূচক ওভারফ্লোগুলির জন্য চেকগুলি অক্ষম করে । উদাহরণস্বরূপ, -Ofastনীচের সুইফট কোডটি ক্র্যাশ না করে নীরবে চলে (এবং কিছু আবর্জনা ছাপিয়ে):

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

তাই -Ofastআমরা কি চাই না; সুইফটের পুরো বিষয়টি হ'ল আমাদের কাছে সুরক্ষার জাল রয়েছে। অবশ্যই, সুরক্ষা জালগুলির পারফরম্যান্সে কিছুটা প্রভাব রয়েছে, তবে তাদের প্রোগ্রামগুলি 100 গুণ কম করা উচিত নয়। মনে রাখবেন যে জাভা ইতিমধ্যে অ্যারে বাউন্ডগুলি পরীক্ষা করে এবং সাধারণ ক্ষেত্রে, মন্দা 2 এর চেয়ে অনেক কম ফ্যাক্টর দ্বারা হয় And এবং কলং এবং জিসিসিতে আমরা পেয়েছি-ftrapv (স্বাক্ষরিত) পূর্ণসংখ্যার ওভারফ্লোগুলি যাচাই করার জন্য , এবং এটি ধীর নয়।

তাই প্রশ্ন: সুরক্ষা জাল না হারিয়ে কীভাবে আমরা সুইফটে যুক্তিসঙ্গত পারফরম্যান্স পেতে পারি?

---

সম্পাদনা 2: আমি লাইনের সাথে খুব সাধারণ লুপগুলি সহ আরও কিছু বেঞ্চমার্কিং করেছি

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

(এখানে জোর অপারেশনটি ঠিক আছে যাতে আমি আরও সহজেই সমাবেশ কোডে প্রাসঙ্গিক লুপটি সন্ধান করতে পারি I আমি এমন একটি অপারেশন বাছাই করার চেষ্টা করেছি যা স্পষ্ট করার পক্ষে সহজ তবে "নিরীহ" এই অর্থেও যে এটির জন্য কোনও চেকের প্রয়োজন নেই) পূর্ণসংখ্যার উপচে পড়তে।)

আবার, তার মাঝে কর্মক্ষমতা একটি বিশাল পার্থক্য ছিল -O3এবং -Ofast। সুতরাং আমি সমাবেশ কোডটি একবার দেখেছি:

• সঙ্গে -Ofastআমি প্রায় কাছাকাছি আমি যা আশা পান। প্রাসঙ্গিক অংশটি 5 টি মেশিন ভাষার নির্দেশাবলী সহ একটি লুপ।

• এর সাথে -O3আমি এমন কিছু পেয়েছি যা আমার কল্পনার বাইরে ছিল। অভ্যন্তরীণ লুপটি সমাবেশ কোডের ৮৮ টি লাইনের বিস্তৃত। আমি এগুলি সব বোঝার চেষ্টা করি নি, তবে সর্বাধিক সন্দেহজনক অংশগুলি হ'ল "কলক _সুইফট_রেইন" এর 13 টি আহবান এবং "কলক _সুইফ্ট_রিলিজ" এর আরও 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]
    }
}

কোনও পাটিগণিত নেই, সুতরাং আমাদের পূর্ণসংখ্যার ওভারফ্লো সম্পর্কে চিন্তা করার দরকার নেই। কেবলমাত্র আমরা যা করি তা হ'ল প্রচুর অ্যারে রেফারেন্স। এবং ফলাফলগুলি এখানে রয়েছে — সুইফট -33 -অফেষ্টের সাথে তুলনায় প্রায় 500 ফ্যাক্টর দ্বারা হারায়:

• সি ++ -O3: 0.05 এস
• সি ++ -O0: 0.4 এস
• জাভা: 0.2 এস
• পাইপাই সহ পাইথন: 0.5 এস
• পাইথন: 12 এস
• সুইফ্ট-ওয়েস্ট: 0.05 এস
• সুইফট -O3: 23 এস
• সুইফট -O0: 443 এস

(আপনি যদি উদ্বিগ্ন হন যে সংকলকটি অর্থহীন লুপগুলি সম্পূর্ণরূপে অপ্টিমাইজ করতে পারে তবে আপনি এটিকে উদাহরণ হিসাবে পরিবর্তন করতে পারেন x[i] ^= x[j]এবং একটি মুদ্রণ বিবৃতি যোগ করতে পারেন যা ফলাফল x[0]দেয় This

এবং হ্যাঁ, এখানে পাইথন বাস্তবায়ন ছিল একটি নির্বুদ্ধ খাঁটি পাইথন বাস্তবায়ন ts এটি অবিক্রিত সুইফ্টের চেয়ে অনেক ধীর হওয়া উচিত । কিছু মনে হচ্ছে সুইফট এবং অ্যারে সূচক দিয়ে গুরুতরভাবে ভেঙে গেছে।

---

সম্পাদনা 4: এই সমস্যাগুলি (পাশাপাশি কিছু অন্যান্য পারফরম্যান্সের সমস্যাগুলি) Xcode 6 বিটা 5 এ স্থির করা হয়েছে বলে মনে হচ্ছে।

বাছাইয়ের জন্য, আমার এখন নিম্নলিখিত সময়গুলি রয়েছে:

• ঝনঝন ++ -O3: 0.06 এস
• swiftc -O ব্রেকফাস্ট: 0.1 s
• swiftc -O: 0.1 s
• swiftc: 4 s

নেস্টেড লুপগুলির জন্য:

• ঝনঝন ++ -O3: 0.06 এস
• swiftc -Ofast: 0.3 s
• swiftc -O: 0.4 s
• swiftc: 540 s

দেখে মনে হয় যে অনিরাপদ -Ofast(ওরফে -Ounchecked) ব্যবহারের আর কোনও কারণ নেই ; প্লেইন -Oসমানভাবে ভাল কোড উত্পাদন করে।

Comments

এখানে আরও একটি "সি এর চেয়ে 100 গুণ কম গতি" প্রশ্নটি রয়েছে: স্ট্যাকওভারফ্লো

— জুলকা সুমোলা

এবং এখানে বাছাইয়ের ক্ষেত্রে সুইফ্টের ভাল পারফরম্যান্স সম্পর্কিত অ্যাপলের বিপণন সামগ্রীর উপর আলোচনা রয়েছে: প্রোগ্রামার্স.স্ট্যাকেক্সেঞ্জাং

— ডটকম / কিউ

আপনার সাথে কম্পাইল করতে পারেন: xcrun --sdk macosx swift -O3। এটা খাটো।

— দক্ষিণী আতিথেয়তা

এই লিঙ্কটি উদ্দেশ্য-সি এর তুলনায় কিছু অন্যান্য বেসিক অপারেশনগুলি দেখায়।

— Wold

বিটা 5 এর সাহায্যে সুইফটের গতিতে যথেষ্ট উন্নতি হয়েছে - আরও বিশদের জন্য জেসি স্কোয়ায়ার্সের এই পোস্টটি দেখুন।

— নোট কুক

Answer 1

tl; ডাঃ সুইফ্ট ১.০ এখন ডিফল্ট প্রকাশের অপ্টিমাইজেশন স্তর [-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)
}

এবং সি তে একই:

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 এর জন্য [-আলোন] এর সাথে সেকেন্ডে সময় :

Swift:            0.895296452
C:                0.001223848

এন = 10_000 এর জন্য সুইফটের অন্তর্নির্মিত সাজান () এখানে রয়েছে :

Swift_builtin:    0.77865783

এন = 10_000 এর জন্য এখানে [-O] :

Swift:            0.045478346
C:                0.000784666
Swift_builtin:    0.032513488

আপনি দেখতে পাচ্ছেন, সুইফ্টের পারফরম্যান্স 20 এর গুণক দ্বারা উন্নত হয়েছে।

অনুযায়ী mweathers 'উত্তর , সেটিং [-Ofast] জন্য এই বার ফলে, বাস্তব পার্থক্য তোলে এন = 10_000 :

Swift:            0.000706745
C:                0.000742374
Swift_builtin:    0.000603576

এবং এন = 1_000_000 এর জন্য :

Swift:            0.107111846
C:                0.114957179
Swift_sort:       0.092688548

তুলনার জন্য, এটি এন = 1_000_000 এর জন্য [-আলোন] এর সাথে রয়েছে :

Swift:            142.659763258
C:                0.162065333
Swift_sort:       114.095478272

সুতরাং কোনও অপ্টিমাইজেশন ছাড়াই সুইফট এর বিকাশের এই পর্যায়ে এই মানদণ্ডের সি এর চেয়ে প্রায় 1000x ধীর ছিল। অন্যদিকে উভয় সংকলককে সেট করে [-Ofest] সুইফট কমপক্ষে পাশাপাশি সি থেকে কিছুটা ভাল না হলেও পারফর্ম করেছে actually

এটি চিহ্নিত করা হয়েছে যে [-Ofیسٹ] ভাষাগুলির শব্দার্থবিজ্ঞান পরিবর্তন করে, এটি সম্ভাব্যভাবে অনিরাপদ করে তোলে। এক্সকোড 5.0 রিলিজ নোটে অ্যাপল এটি বলেছে:

একটি নতুন অপ্টিমাইজেশন স্তর - এলএফভিএম-এ উপলব্ধ, প্রেরণা আক্রমণাত্মক অনুকূলিতকরণ সক্ষম করে en - বেশিরভাগ কোডের জন্য নিরাপদ, বেশিরভাগ ভাসমান-পয়েন্ট অপারেশনের জন্য, কিছু রক্ষণশীল বিধিনিষেধ শিথিল করে। এটি সংকলক থেকে উচ্চ-পারফরম্যান্সের উল্লেখযোগ্য জয় অর্জন করতে পারে।

তারা সকলেই এটিকে সমর্থন করে। এটি বুদ্ধিমান হোক বা না হোক আমি বলতে পারি না, তবে আমি যা বলতে পারি তা থেকে যদি আপনি উচ্চ-নির্ভুলতা ভাসমান বিন্দুটি পাটিগণিত না করেন এবং আপনি কোনও পূর্ণসংখ্যার আত্মবিশ্বাসী না হন তবে একটি রিলিজে এটি ব্যবহার করা যথেষ্ট যুক্তিযুক্ত বলে মনে হচ্ছে or আপনার প্রোগ্রামে অ্যারে ওভারফ্লোগুলি সম্ভব। আপনার যদি উচ্চ পারফরম্যান্স এবং ওভারফ্লো চেক / সুনির্দিষ্ট গাণিতিক প্রয়োজন হয় তবে আপাতত অন্য একটি ভাষা চয়ন করুন।

বিটা 3 আপডেট:

n = 10_000 এর সাথে [-O] :

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

Comments

ইন্টারমিডিয়েট এসআইএল কোড আউটপুট দেওয়ার জন্য -িমিট-সিল ব্যবহার করে কী ধরে রাখা হচ্ছে তা দেখায় (আর্গ, স্ট্যাক ওভারফ্লো এটিকে ফর্ম্যাট করা অসম্ভব করে তোলে)। এটি অ্যারের অভ্যন্তরীণ বাফার অবজেক্ট। এটি অবশ্যই একটি অপ্টিমাইজার বাগের মতো শোনাচ্ছে, এআরসি অপ্টিমাইজারটি -অফেষ্ট ছাড়াই রেন্টগুলি সরিয়ে ফেলতে সক্ষম হবে।

— ক্যাটফিশ_মান

'কেবলমাত্র একমত নই যে অফাস্ট অপটিমাইজেশন ব্যবহার করতে চাইলে আমাদের অন্য একটি ভাষা ব্যবহার করতে হবে। সি এর মতো অন্য ভাষা বেছে নেওয়ার ক্ষেত্রে বাউন্ডস চেক এবং অন্যান্য ছোটখাটো সমস্যার সাথে একইভাবে মোকাবিলা করতে হবে সুইফটটি অবশ্যই খুব সুন্দর কারণ এটি ডিফল্টরূপে সুরক্ষিত এবং প্রয়োজনে বিকল্প এবং দ্রুত এবং নিরাপত্তাহীন হতে হবে। এটি প্রোগ্রামারকে আপনার কোডটিও ডিবাগ করার অনুমতি দেয়, যাতে সমস্ত কিছু ঠিক আছে এবং অফাস্ট ব্যবহার করে সংকলন করা যায়। আধুনিক মানের ব্যবহার এবং এখনও সি এর মতো "অনিরাপদ" ভাষার ক্ষমতা থাকার সম্ভাবনা খুব শীতল।

— ওয়াল্যাক্সি

যদি আপনি আমাকে বলতে পারেন এটি কীভাবে অবৈধ হতে পারে তবে দয়া করে করুন। আমি সর্বদা আরও শিখতে চাই

— জোসেফ মার্ক

একটি চূড়ান্ত আপডেট করেছে, স্ট্যান্ডার্ড অপ্টিমাইজেশন ব্যবহার করে সুইফ্ট এখন এই বেঞ্চমার্ক দ্বারা সি হিসাবে দ্রুত।

— জোসেফ মার্ক

টিপ: কুইকোর্টের আপনার সুইফট এবং সি উভয় বাস্তবায়নই যদি আপনার ক্ষুদ্রতম বিভাগে পুনরাবৃত্তি হয় তবে উন্নতি করা যেতে পারে ! (সর্বদা প্রথমে বাম পার্টিশনটিতে পুনরাবৃত্তি করার পরিবর্তে) কুইকসোর্টটি সবচেয়ে সাধারণ ক্ষেত্রে সাধারণ পাইভট নির্বাচনের সাথে প্রয়োগ করা হয় O (n takes 2) সময় নেয়, তবে এই নিকৃষ্টতম পরিস্থিতিতে আপনার কেবল ও (লগ এন) পুনরাবৃত্তি করে স্ট্যাক স্পেস প্রয়োজন need প্রথমে ছোট পার্টিশনে।

— ম্যাকনিল শোনলে

Answer 2

টি এল; ডিআর : হ্যাঁ, শুধুমাত্র সুইফট ভাষা বাস্তবায়ন ধীর হয়, এখনই । আপনার যদি দ্রুত, সংখ্যাসূচক (এবং অন্যান্য ধরণের কোড, সম্ভবত) কোডের প্রয়োজন হয় তবে কেবল অন্য একটি দিয়ে যান। ভবিষ্যতে, আপনার নিজের পছন্দটিকে পুনরায় মূল্যায়ন করা উচিত। যদিও বেশিরভাগ অ্যাপ্লিকেশন কোডের জন্য এটি উচ্চতর স্তরে লেখা থাকে তবে এটি যথেষ্ট ভাল।

এসআইএল এবং এলএলভিএম আইআরতে আমি যা দেখছি তা থেকে মনে হচ্ছে তাদের ধরে রাখার এবং রিলিজগুলি অপসারণের জন্য একগুচ্ছ অপ্টিমাইজেশন প্রয়োজন, যা ক্ল্যাং (অবজেক্টিভ-সি এর জন্য) এ প্রয়োগ করা যেতে পারে , তবে তারা এখনও তাদের পোর্ট করেনি। এই যে তত্ত্বটি আমি নিয়ে চলেছি (আপাতত ... এখনও আমার নিশ্চিত হওয়া দরকার যে ক্ল্যাং এটি সম্পর্কে কিছু করেছে), যেহেতু এই প্রশ্নের শেষ পরীক্ষার ক্ষেত্রে একজন প্রোফাইলার এই "চমত্কার" ফলাফল অর্জন করেছেন:

যেমনটি আরও অনেকের দ্বারা বলা হয়েছিল, -Ofastসম্পূর্ণরূপে অনিরাপদ এবং ভাষা শব্দার্থকে পরিবর্তন করে। আমার জন্য, এটি "যদি আপনি এটি ব্যবহার করতে চলেছেন তবে কেবল অন্য ভাষা ব্যবহার করুন" পর্যায়ে রয়েছে। আমি পরে সেই পছন্দটি পুনরায় মূল্যায়ন করব, যদি এটি পরিবর্তন হয়।

-O3আমাদের একটি গোছা পেয়ে যায় swift_retainএবং swift_releaseকল করে যে, সত্যই, উদাহরণস্বরূপ তাদের সেখানে থাকা উচিত নয়। অপ্টিমাইজারটি এএএএফসিটি তাদের বেশিরভাগ ক্ষেত্রেই উচিত ছিল, কারণ এটি অ্যারের সম্পর্কে বেশিরভাগ তথ্য জানে এবং জানে যে এটির (কমপক্ষে) এর একটি দৃ reference় উল্লেখ রয়েছে।

এমনকি যখন এটি ফাংশনগুলি কল করে না যা অবজেক্টগুলি প্রকাশ করতে পারে তখন এটি বেশি রক্ষণাবেক্ষণ না করে। আমি মনে করি না যে অ্যারে কনস্ট্রাক্টর কোন অ্যারের ফিরিয়ে দিতে পারে যা চেয়েছিল তার চেয়ে ছোট, যার অর্থ প্রচুর চেক নিঃসৃত হয় নিরর্থক। এটি আরও জানে যে পূর্ণসংখ্যাটি কখনই 10 কের বেশি হবে না, সুতরাং ওভারফ্লো চেকগুলি অনুকূলিত করা যেতে পারে ( -Ofastঅদ্ভুততার কারণে নয় , তবে ভাষার শব্দার্থিক কারণে (অন্য কোনও কিছুই পরিবর্তিত হয় না এবং এটি অ্যাক্সেস করতে পারে না এবং 10 কে পর্যন্ত যোগ করতে পারে ধরণের জন্য নিরাপদ Int)।

সংকলক অ্যারে বা অ্যারের উপাদানগুলিকে আনবক্স করতে সক্ষম হতে পারে না, যদিও তারা যেহেতু পাস হচ্ছে sort(), যা একটি বাহ্যিক ফাংশন এবং এটি প্রত্যাশিত যুক্তিগুলি পাবে to এটি আমাদেরকে Intপরোক্ষভাবে মানগুলি ব্যবহার করতে হবে, যা এটি কিছুটা ধীরে ধীরে যেতে পারে। sort()জেনেরিক ফাংশন (মাল্টি-মেথড পদ্ধতিতে নয়) সংকলকটিতে উপলব্ধ থাকায় এবং ইনলাইনড হয়ে উঠলে এটি পরিবর্তিত হতে পারে ।

এটি একটি খুব নতুন (প্রকাশ্য) ভাষা, এবং এটি আমি যা অনুমান করি তা প্রচুর পরিবর্তন ঘটছে, যেহেতু সুইফ ভাষার সাথে জড়িত ব্যক্তিরা (ভারী) প্রতিক্রিয়া চেয়েছে এবং তারা সবাই বলে যে ভাষাটি শেষ হয়নি এবং হবে পরিবর্তন.

কোড ব্যবহৃত:

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")

পিএস: আমি ওজেক্টিভ-সি তে বিশেষজ্ঞ নই বা কোকো , অবজেক্টিভ-সি, বা সুইফট রানটাইমস থেকে সমস্ত সুবিধা নেই । আমি এমন কিছু জিনিসও ধরে নিচ্ছি যা আমি লিখিনি।

Comments

সংকলক অ্যারে বা অ্যারের উপাদানগুলি আনবক্স করতে সক্ষম নাও হতে পারে, যদিও তারা বাছাই করতে চলেছে () যা একটি বাহ্যিক ফাংশন এবং এটি প্রত্যাশিত যুক্তিগুলি পেতে হবে। এটি তুলনামূলকভাবে ভাল সংকলকের ক্ষেত্রে গুরুত্বপূর্ণ নয়। প্রকৃত ডেটা সম্পর্কে মেটাডেটা পাসিং (পয়েন্টারে - bits৪ বিটগুলি প্রচুর পরিমাণে লেভির প্রস্তাব দেয়) এবং এটি ডাকা ফাংশনে শাখা করে।

— বেটসেস

-Ofast"সম্পূর্ণ অনিরাপদ" ঠিক কী করে তোলে ? ধরে নিচ্ছি যে কীভাবে আপনার কোডটি পরীক্ষা করতে হবে এবং ওভারফ্লোগুলিকে নিয়ন্ত্রিত করবেন।

— জোসেফ মার্ক

@ সিজেহপ: এটি আসলে অনেকটা ধরে নিচ্ছে :-) কোডটি পরীক্ষা করা এবং ওভারফ্লোগুলি বাতিল করা শক্ত কাজ। আমার অভিজ্ঞতা থেকে (আমি সংকলক কাজ করি এবং কয়েকটি বড় কোডবেস পরীক্ষা করে দেখেছি), এবং আমি বিপুল সংস্থাগুলিতে সংকলক কাজ করে এমন লোকদের কাছ থেকে যা শুনেছি, ওভারফ্লো এবং অন্যান্য অপরিজ্ঞাত আচরণ করা শক্ত । এমনকি ইউবি ঠিক করার বিষয়ে অ্যাপলের পরামর্শ (কেবলমাত্র একটি উদাহরণ) ভুল, কখনও কখনও ( র্যান্ডোম্যাসি.ওয়ার্ডপ্রেস.কম / 2014/04/17/2 ) is -Ofastভাষা শব্দার্থবিজ্ঞানও পরিবর্তন করে, তবে আমি এটির জন্য কোনও ডক্সকে তহবিল দিতে পারি না। আপনি কীভাবে আত্মবিশ্বাসী হতে পারেন যা আপনি জানেন যে এটি কী করছে?

— ফিলক্যাব

@ বেস্টেস: এটি সম্ভব, তবে এটি কার্যকর নাও হতে পারে। এটি কোনও ইন্টার [] এর প্রতিটি অ্যাক্সেসে চেক যুক্ত করে। এটি নির্ভর করে যদি ইন্টের অ্যারে এবং কয়েকটি অন্যান্য আদিম ধরণের (আপনার কাছে সর্বাধিক 3 বিট থাকে) প্রচুর ব্যবহৃত হয় (বিশেষত যখন আপনি প্রয়োজন হলে সিতে নামাতে পারেন)। এটি কিছু বিটও ব্যবহার করে যা তারা ব্যবহার করতে চাইলে শেষ পর্যন্ত তারা নন-আরসি জিসি যুক্ত করতে চায়। এটি একাধিক যুক্তি দিয়ে জেনেরিকগুলিতে স্কেল করে না either যেহেতু তাদের সকল প্রকারের রয়েছে তাই ইনলাইনড ইনট ব্যবহার করতে আন্তঃ [] (তবে ইন্ট নয়? []) স্পর্শ করা সমস্ত কোডকে বিশেষীকরণ করা আরও সহজ হবে। তবে তারপরে আপনার উদ্বেগের জন্য ওবজ-সি ইন্টারপ রয়েছে।

— ফিলাক্যাব

@ ফিলক্যাব, নন-এআরসি (অর্থাত্ বাস্তব) জিসি আসলে কার্যকর হবে তবে তাদের এমন কিছু প্রয়োজন যা সি সামঞ্জস্যপূর্ণ নয় যদি তারা সত্যিকারের সমবর্তী, নন-এসটিডাব্লু জিসি চায় want আমি 'প্রতিটি অ্যাক্সেস' নিয়ে চিন্তা করব না Int[]যেহেতু এটি কম্পাইলারটি ইনলাইন করতে পারে সেই স্তরের উপর নির্ভর করে এবং এটি কিছু দিকনির্দেশনার পরে / পরে টাইট লুপগুলি ইনলাইন করতে সক্ষম হওয়া উচিত।

— বেসসেস

Answer 3

আমি মজা করার জন্য এটি একবার দেখে নেওয়ার সিদ্ধান্ত নিয়েছি এবং আমি যে সময় পেয়েছি তা এখানে:

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

সুইফট ১.২

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

সুইফট ২.০

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

সুইচ 4 আবার পারফরম্যান্সের উন্নতি করে -Oএবং এর মধ্যে ব্যবধান বজায় রেখে -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, এটি সুইফট ৪.০.২ এবং অ্যাপল এলএলভিএম ৯.০.০ তে সি ++ এর মতো দ্রুতগতির বলে মনে হচ্ছে।

Comments

বাস্তবে আপনার দশ মিলিয়ন উপাদান সন্নিবেশ করার আগে কখনও ভেক্টর :: রিজার্ভ () কল করা উচিত নয় ।

— বিজেভকে

সম্ভবত! এই মুহুর্তে কেবল বাছাইয়ের সময়সীমা করা হচ্ছে।

— ওপেনজিএল ইএস

Answer 4

থেকে 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 }

ক্লোজারটি যুক্ত হওয়ার সাথে সাথে আমি খেলার মাঠে আপনার কোডের একটি পরিবর্তিত সংস্করণ পরীক্ষা করেছি যাতে আমি ফাংশনটি আরও ঘনিষ্ঠভাবে পর্যবেক্ষণ করতে পারি, এবং আমি দেখতে পেয়েছি যে এন সেট 1000 সহ, বন্ধটি প্রায় 11,000 বার বলা হচ্ছে।

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
}

এন = 1000 দিয়ে এটি ব্যবহার করে, আমি এটি পেয়েছি

1. কুইকসোর্ট () প্রায় 650 বার কল হয়েছিল,
2. প্রায় 6000 অদলবদল তৈরি করা হয়েছিল,
3. এবং প্রায় 10,000 টি তুলনা রয়েছে

দেখে মনে হচ্ছে বিল্ট-ইন বাছাইয়ের পদ্ধতিটি দ্রুত সাজানোর (বা তার কাছে) খুব ধীরে ধীরে ধীরে ধীরে ...

Comments

সম্ভবত আমি সম্পূর্ণ ভুল, তবে এন.ইউইউইকিপিডিয়া / উইকি / কুইকোর্টের মতে, কুইকোর্টে তুলনা করার গড় সংখ্যা 2*n*log(n)। এটি এন = 1000 উপাদান বাছাইয়ের জন্য 13815 তুলনা, সুতরাং তুলনা ফাংশনটি যদি প্রায় 11000 বার বলা হয় যা এত খারাপ বলে মনে হয় না।

— মার্টিন আর

এছাড়াও অ্যাপল দাবি করেছে যে পাইথনের তুলনায় একটি "জটিল অবজেক্ট সাজ্ট" (যা কিছু হোক না কেন) সুইফটে ৩.৯ গুণ বেশি গতিযুক্ত। সুতরাং এটি "আরও ভাল বাছাইয়ের ফাংশন" সন্ধানের প্রয়োজন হবে না। - তবে সুইফট এখনও বিকাশে রয়েছে ...

— মার্টিন আর

এটা তোলে নেই স্বাভাবিক লগারিদম পড়ুন।

— মার্টিন আর

log(n)অ্যালগরিদমিক জটিলতার জন্য সাধারণত লগ বেস -২ বোঝায় to বেসটি উল্লেখ না করার কারণ হ'ল লগারিদমগুলির জন্য পরিবর্তন-ভিত্তিক আইনটি কেবল একটি ধ্রুবক গুণককে পরিচয় করে, যা ও-স্বীকৃতির উদ্দেশ্যে বাতিল করা হয়।

— মিনিটম্যান 3

প্রাকৃতিক লোগারিদম বনাম বেস 2 লোগারিদম সম্পর্কে আলোচনা সম্পর্কে: উইকিপিডিয়া পৃষ্ঠা থেকে সুনির্দিষ্ট বক্তব্যটি হ'ল এন উপাদানগুলির জন্য প্রয়োজনীয় তুলনার গড় সংখ্যা C(n) = 2n ln n ≈ 1.39n log₂ n। এন = 1000 জন্য এই সি (ঢ) = 13815 দেয়, এবং এটা না একটি "বড় হে স্বরলিপি"।

— মার্টিন আর

Answer 5

এক্সকোড 7 হিসাবে আপনি চালু করতে পারেন Fast, Whole Module Optimization। এটি অবিলম্বে আপনার কর্মক্ষমতা বৃদ্ধি করা উচিত।

Answer 6

সুইফ্ট অ্যারে পারফরম্যান্স পুনর্বিবেচিত:

আমি সুইফের সাথে সি / অবজেক্টিভ-সি এর সাথে তুলনা করে আমার নিজস্ব বেঞ্চমার্ক লিখেছিলাম। আমার মানদণ্ডটি মৌলিক সংখ্যা গণনা করে। এটি প্রতিটি নতুন প্রার্থীর প্রধান উপাদানগুলির জন্য পূর্ববর্তী মৌলিক সংখ্যার অ্যারে ব্যবহার করে, তাই এটি বেশ দ্রুত। যাইহোক, এটি অ্যারে পড়ার টোন, এবং অ্যারেতে কম লেখায়।

আমি মূলত সুইফট ১.২ এর বিপরীতে এই মানদণ্ডটি করেছি। আমি প্রকল্পটি আপডেট করার এবং এটি সুইফট ২.০ এর বিপরীতে চালানোর সিদ্ধান্ত নিয়েছি।

প্রকল্পটি আপনাকে সাধারণ সুইফ্ট অ্যারে ব্যবহার এবং অ্যারে শব্দার্থবিজ্ঞান ব্যবহার করে সুইফট অনিরাপদ মেমরি বাফার ব্যবহারের মধ্যে নির্বাচন করতে দেয়।

সি / অবজেক্টিভ-সি এর জন্য আপনি হয় এনএসআরাই, বা সি ম্যালোক'ড অ্যারে ব্যবহার করতে পারেন।

দ্রুততম, ক্ষুদ্রতম কোড অপ্টিমাইজেশনের ([-0s]) বা দ্রুততম, আগ্রাসী ([-0 ব্রেকফাস্ট]) অপ্টিমাইজেশনের সাথে পরীক্ষার ফলাফলগুলি বেশ সমান বলে মনে হচ্ছে।

কোড অপ্টিমাইজেশন বন্ধ হয়ে গেলেও সুইফট ২.০ পারফরম্যান্সটি ভয়াবহ, যদিও সি / অবজেক্টিভ-সি পারফরম্যান্সটি কেবলমাত্র মাঝারি ধীর।

নীচের লাইনটি হ'ল সি ম্যালোক'ড অ্যারে-ভিত্তিক গণনাগুলি খুব সামান্যতম ব্যবধানের দ্বারা দ্রুততম

অনিরাপদ বাফারগুলির সাথে স্যুইটটি দ্রুততম, ক্ষুদ্রতম কোড অপ্টিমাইজেশন ব্যবহার করার সময় সি ম্যালোক'ড অ্যারেগুলির চেয়ে 1.19X - 1.20X বেশি সময় নেয়। দ্রুত, আক্রমণাত্মক অপ্টিমাইজেশানের সাথে পার্থক্যটি কিছুটা কম বলে মনে হয় (সুইফট সি এর চেয়ে 1.18x থেকে 1.16x বেশি সময় নেয়

আপনি যদি নিয়মিত সুইফ্ট অ্যারে ব্যবহার করেন তবে সি এর সাথে পার্থক্যটি সামান্য বেশি। (সুইফ্টটি ~ 1.22 থেকে 1.23 বেশি সময় নেয়))

নিয়মিত সুইফ্ট অ্যারে হয় DRAMATICALLY সুইফট ১.২ / এক্সকোড in-এর তুলনায় দ্রুততর Their

বিটিডাব্লু, অবজেক্টিভ-সি এনএসআরির পারফরম্যান্সের দুর্গন্ধ। আপনি যদি উভয় ভাষায় নেটিভ ধারক বস্তু ব্যবহার করতে চলেছেন তবে সুইফট ভয়ঙ্করভাবে দ্রুত।

আপনি সুইফট পারফরম্যান্সবেঞ্চমার্কে গিথুবটিতে আমার প্রকল্পটি দেখতে পারেন

এটিতে একটি সাধারণ ইউআই রয়েছে যা পরিসংখ্যান সংগ্রহ করা বেশ সহজ করে তোলে।

এটি আকর্ষণীয় যে বাছাই করা এখন সি-র তুলনায় সুইফ্টে কিছুটা দ্রুত গতিযুক্ত বলে মনে হচ্ছে, তবে এই প্রধান সংখ্যাটি অ্যালগরিদম এখনও সুইফটে আরও দ্রুত।

Answer 7

অন্যদের দ্বারা উল্লিখিত তবে পর্যাপ্ত পরিমাণে বলা হয়নি এমন মূল বিষয়টি হ'ল -O3সুইফ্টে (এবং কখনও হয় নি) কিছুই হয় না তাই যখন এটি সংকলিত হয় তখন কার্যকরভাবে অপ্টিমাইজড ( -Onone) হয় না।

বিকল্পের নাম সময়ের সাথে সাথে পরিবর্তিত হয়েছে তাই কিছু অন্যান্য উত্তরে বিল্ড বিকল্পগুলির জন্য অপ্রচলিত পতাকা রয়েছে। সঠিক বর্তমান বিকল্পগুলি (সুইফট ২.২) হ'ল:

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

পুরো মডিউল অপ্টিমাইজেশনের একটি ধীর সংকলন রয়েছে তবে মডিউলটির মধ্যে ফাইলগুলি যেমন প্রতিটি কাঠামোর মধ্যে এবং প্রকৃত অ্যাপ্লিকেশন কোডের মধ্যে নয় তবে তাদের মধ্যে নয় optim সমালোচনামূলক কোনও পারফরম্যান্সের জন্য আপনার এটি ব্যবহার করা উচিত)

আপনি আরও বেশি গতির জন্য সুরক্ষা চেকগুলি অক্ষম করতে পারেন তবে সমস্ত দৃ and়তা এবং পূর্ব শর্তাদি কেবল অক্ষম নয় বরং সেই ভিত্তিতেই যথাযথ they যদি আপনি কখনও দৃ hit়তার সাথে আঘাত করেন তবে এর অর্থ হ'ল আপনি অনির্ধারিত আচরণে রয়েছেন। অত্যন্ত সতর্কতার সাথে ব্যবহার করুন এবং কেবলমাত্র যদি আপনি নির্ধারণ করেন যে গতির উত্সাহ আপনার পক্ষে (পরীক্ষা করে) সার্থক। আপনি যদি কিছু কোডের পক্ষে এটি মূল্যবান বলে মনে করেন তবে আমি সেই কোডটি একটি পৃথক কাঠামোর মধ্যে পৃথক করে এবং কেবলমাত্র সেই মডিউলটির জন্য সুরক্ষা চেকগুলি অক্ষম করার পরামর্শ দিই।

Comments

এই উত্তরটি এখন পুরানো। সুইফট ৪.১ অনুসারে পুরো মডিউল অপ্টিমাইজেশন অপশনটি একটি পৃথক বুলিয়ান যা অন্যান্য সেটিংসের সাথে মিলিত হতে পারে এবং আকারের জন্য অনুকূলকরণের জন্য এখন একটি -ও রয়েছে। সঠিক বিকল্পের পতাকাগুলি যাচাই করার সময় পেলে আমি আপডেট করতে পারি।

— জোসেফ লর্ড

Answer 8

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) 

এটি দ্রুত বাছাই সম্পর্কে আমার ব্লগ - গিথুব নমুনা দ্রুত-বাছাই

তালিকার বিভাজনে আপনি লোমুতোর বিভাজন অ্যালগরিদমটি একবার দেখে নিতে পারেন। সুইফটে লেখা।

Answer 9

সুইফট ৪.১ নতুন -Osizeঅপ্টিমাইজেশন মোড উপস্থাপন করেছে।

সুইফটে ৪.১-এ সংকলকটি এখন নতুন অপ্টিমাইজেশন মোড সমর্থন করে যা কোডের আকার হ্রাস করতে ডেডিকেটেড অপ্টিমাইজেশানগুলিকে সক্ষম করে।

সুইফ্ট সংকলকটি শক্তিশালী অপ্টিমাইজেশনের সাথে আসে। -O দিয়ে সংকলন করার সময় সংকলক কোডটি রূপান্তর করার চেষ্টা করে যাতে এটি সর্বাধিক কার্য সম্পাদন করে। তবে রানটাইম পারফরম্যান্সের এই উন্নতিটি কখনও কখনও কোডের আকারের বর্ধনের সাথে আসতে পারে। নতুন-আকারের অপ্টিমাইজেশন মোডের সাথে ব্যবহারকারীর সর্বাধিক গতির চেয়ে কমপক্ষে কোড আকারের জন্য সংকলন করার পছন্দ রয়েছে।

কমান্ড লাইনে আকার অপ্টিমাইজেশন মোড সক্ষম করতে -O এর পরিবর্তে -Osize ব্যবহার করুন।

আরও পড়ুন: https://swift.org/blog/osize/