swift - সুইট বিটা কর্মক্ষমতা: বাছাই অ্যারে




performance sorting (6)

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

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.06 সেকেন্ডে লাগে।

পাইথনটিতে এটি 0.6s (কোনও কৌশল নয়, শুধু y = সাজানো (x) পূর্ণসংখ্যাগুলির তালিকার জন্য নেয়)।

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

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

এবং যদি আমি নিম্নোক্ত কমান্ডটিকে কম্পাইল করে তবে 88 সেকেন্ডের বেশি সময় লাগে:

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

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

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

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

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

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

অতএব প্রশ্নঃ স্নিফ্টে নিরাপত্তার জাল ছাড়া আমরা কীভাবে যুক্তিসঙ্গত পারফরমেন্স পেতে পারি?

সম্পাদনা 2: আমি আরো কিছু benchmarking, লাইন বরাবর খুব সহজ loops সঙ্গে

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

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

আবার, -O3 এবং -Ofast মধ্যে পারফরম্যান্স মধ্যে একটি বিশাল পার্থক্য ছিল। তাই আমি সমাবেশ কোড তাকান ছিল:

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

  • সঙ্গে -O3 আমি আমার wildest কল্পনা অতিক্রম ছিল যে কিছু পেতে। ভিতরের লুপ সমাবেশ কোড 88 লাইন spans। আমি এটি সব বুঝতে চেষ্টা করি নি, তবে সবচেয়ে সন্দেহজনক অংশগুলি "কলক_সুইফ্ট_টেনাইন" এবং 13 টি "কলক _ স্যুইফট্রিলিভ" এর অন্য 13 টি আমন্ত্রণপত্র। যে, 26 subroutine ভিতরের লুপ কল !

সম্পাদনা 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]
    }
}

কোন গাণিতিক আছে, তাই আমরা পূর্ণসংখ্যা overflows সম্পর্কে চিন্তা করতে হবে না। আমরা যা শুধুমাত্র জিনিস অ্যারের রেফারেন্স প্রচুর। এবং ফলাফল এখানে-সুইফ্ট-ও 3 ফ্যাক্টর দ্বারা প্রায় 500 তুলনায় হারায় -অফাস্ট:

  • C ++ -O3: 0.05 গুলি
  • সি ++-ও0: 0.4 সে
  • জাভা: 0.2 এস
  • PyPy সঙ্গে পাইথন: 0.5 গুলি
  • পাইথন: 12 এস
  • সুইফ্ট-ওফ্ট: 0.05 সে
  • সুইফ্ট-ও 3: ২3 শে
  • সুইফ্ট -00: 443 গুলি

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

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

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

সাজানোর জন্য, আমি এখন নিম্নলিখিত সময় আছে:

  • clang ++ -O3: 0.06 গুলি
  • Swiftc - অস্থায়ী: 0.1 সে
  • swiftc -O: 0.1 গুলি
  • Swiftc: 4 গুলি

নেস্টেড loops জন্য:

  • clang ++ -O3: 0.06 গুলি
  • Swiftc - অস্থায়ী: 0.3 সে
  • swiftc -O: 0.4 সে
  • Swiftc: 540 গুলি

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


tl; dr Swift 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)
}

এবং সি মধ্যে একই:

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.

এন = 10_000 এর জন্য [-অনেনি] সহ সেকেন্ডে সময়:

Swift:            0.895296452
C:                0.001223848

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

Swift_builtin:    0.77865783

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

Swift:            0.045478346
C:                0.000784666
Swift_builtin:    0.032513488

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

মিউদারসের উত্তর অনুসারে , [-অফাস্ট] সেটিংটি প্রকৃত পার্থক্য তৈরি করে, যার ফলে এন = 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 এর জন্য [-Onone] এর সাথে রয়েছে :

Swift:            142.659763258
C:                0.162065333
Swift_sort:       114.095478272

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

এটি উল্লেখ করা হয়েছে যে [-অফাস্ট] ভাষাটির সেম্যান্টিক্স পরিবর্তন করে, এটি সম্ভাব্য অনিরাপদ করে তোলে। অ্যাপল রাজ্যের Xcode 5.0 রিলিজ নোটগুলিতে এটি যা বলে তা হল:

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

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

বিটা 3 আপডেট:

এন = 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

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

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

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

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

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


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


সুইফ্ট অ্যারে কর্মক্ষমতা revisited:

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

আমি মূলত সুইফ্ট 1.2 এর বিরুদ্ধে এই বেঞ্চমার্ক করেছি। আমি প্রকল্পের আপডেট এবং সুইফট 2.0 বিরুদ্ধে এটি চালানোর সিদ্ধান্ত নিয়েছে।

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

C / Objective-C এর জন্য, আপনি NSArrays বা C malloc'ed arrays ব্যবহার করতে পারেন।

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

সুইফ্ট 2.0 কার্যক্ষমতা এখনও কোড অপ্টিমাইজেশান বন্ধের সাথে ভয়ানক, আর সি / উদ্দেশ্য-সি কার্যকারিতা শুধুমাত্র মাঝারি ধীর।

নিচের লাইনটি হল সি malloc'd অ্যারের-ভিত্তিক গণনা একটি শালীন মার্জিন দ্বারা দ্রুততম

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

আপনি যদি নিয়মিত সুইফ্ট অ্যারে ব্যবহার করেন, তবে C এর সাথে পার্থক্য সামান্য বেশি। (সুইফ্ট লাগে 1.2২ থেকে 1.23 আর।)

নিয়মিত সুইফ্ট অ্যারেগুলি সুইফ্ট 1.2 / DRAMATICALLY চেয়ে দ্রুত গতিতে রয়েছে। তাদের কর্মক্ষমতা DRAMATICALLY অসুরক্ষিত বাফার ভিত্তিক অ্যারের কাছে এত কাছাকাছি, যেগুলি অনিরাপদ মেমরি বাফারগুলি ব্যবহার করে সেগুলি আর কোনও DRAMATICALLY মূল্যবান বলে মনে হয় না, যা বড়।

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

আপনি SwiftPerformanceBenchmark এ Github এ আমার প্রকল্পটি পরীক্ষা করতে পারেন

এটি একটি সহজ UI রয়েছে যা স্ট্যাটাসগুলি সংগ্রহ করা সহজ করে তোলে।

এটি স্বতঃস্ফূর্ত যে স্নিফ্টটি এখন C এর তুলনায় দ্রুততর বলে মনে হচ্ছে, তবে সুইফ্টের এই প্রাথমিক সংখ্যা অ্যালগরিদম এখনও দ্রুত।


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

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

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

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

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

যদিও কম্পাইলার অ্যারে বা অ্যারের উপাদানের আনবক্স করতে সক্ষম নাও হতে পারে, যদিও তারা ক্রমবর্ধমান sort() , যা বহিরাগত ফাংশন হয় এবং এটি প্রত্যাশিত আর্গুমেন্টগুলি পেতে চলেছে। এটি আমাদেরকে পরোক্ষভাবে 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")

PS: আমি উদ্দেশ্য-সি-তে কোন বিশেষজ্ঞ নই এবং Cocoa , উদ্দেশ্য-সি, বা সুইফট রানটাইমগুলির সমস্ত সুবিধাও নই। আমি এমন কিছু জিনিসও ধরতে পারি যা আমি লিখি নি।


সুইফট 4.1 নতুন- -Osize অপ্টিমাইজেশান মোড প্রবর্তন করে।

সুইফ্ট 4.1 এ কম্পাইলারটি এখন একটি নতুন অপ্টিমাইজেশান মোড সমর্থন করে যা কোডের আকার কমাতে ডেডিকেটেড অপটিমাইজেশন সক্ষম করে।

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

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

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





compiler-optimization