Menjawab pertanyaan Stack Overflow lainnya (yang ini ) saya menemukan sub-masalah yang menarik. Apa cara tercepat untuk mengurutkan array 6 bilangan bulat?

Karena tingkat pertanyaannya sangat rendah:

• kami tidak dapat menganggap perpustakaan tersedia (dan panggilan itu sendiri biayanya), hanya C biasa
• untuk menghindari pengosongan pipa instruksi (yang memiliki biaya yang sangat tinggi) kita mungkin harus meminimalkan cabang, lompatan, dan setiap jenis aliran kontrol lainnya (seperti yang tersembunyi di belakang titik urutan &&atau ||).
• ruangan dibatasi dan meminimalkan register dan penggunaan memori adalah masalah, idealnya di tempat semacam itu mungkin yang terbaik.

Sungguh pertanyaan ini adalah semacam Golf di mana tujuannya bukan untuk meminimalkan panjang sumber tetapi waktu eksekusi. Saya menyebutnya kode 'Zening' seperti yang digunakan dalam judul buku Zen of Code optimisasi oleh Michael Abrash dan sekuelnya .

Adapun mengapa itu menarik, ada beberapa lapisan:

• contohnya sederhana dan mudah dipahami dan diukur, tidak banyak keterampilan C yang terlibat
• itu menunjukkan efek pilihan dari algoritma yang baik untuk masalah, tetapi juga efek dari kompiler dan perangkat keras yang mendasarinya.

Inilah implementasi referensi saya (naif, tidak dioptimalkan) dan set pengujian saya.

#include <stdio.h>

static __inline__ int sort6(int * d){

    char j, i, imin;
    int tmp;
    for (j = 0 ; j < 5 ; j++){
        imin = j;
        for (i = j + 1; i < 6 ; i++){
            if (d[i] < d[imin]){
                imin = i;
            }
        }
        tmp = d[j];
        d[j] = d[imin];
        d[imin] = tmp;
    }
}

static __inline__ unsigned long long rdtsc(void)
{
  unsigned long long int x;
     __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
     return x;
}

int main(int argc, char ** argv){
    int i;
    int d[6][5] = {
        {1, 2, 3, 4, 5, 6},
        {6, 5, 4, 3, 2, 1},
        {100, 2, 300, 4, 500, 6},
        {100, 2, 3, 4, 500, 6},
        {1, 200, 3, 4, 5, 600},
        {1, 1, 2, 1, 2, 1}
    };

    unsigned long long cycles = rdtsc();
    for (i = 0; i < 6 ; i++){
        sort6(d[i]);
        /*
         * printf("d%d : %d %d %d %d %d %d\n", i,
         *  d[i][0], d[i][6], d[i][7],
         *  d[i][8], d[i][9], d[i][10]);
        */
    }
    cycles = rdtsc() - cycles;
    printf("Time is %d\n", (unsigned)cycles);
}

Hasil mentah

Karena jumlah varian menjadi besar, saya mengumpulkan semuanya di ruang uji yang dapat ditemukan di sini . Tes yang sebenarnya digunakan sedikit lebih naif dari yang ditunjukkan di atas, terima kasih kepada Kevin Stock. Anda dapat mengkompilasi dan menjalankannya di lingkungan Anda sendiri. Saya cukup tertarik dengan perilaku arsitektur target / kompiler yang berbeda. (OK teman, taruh di jawaban, saya akan memberi +1 setiap kontributor dari hasil baru).

Saya memberikan jawaban kepada Daniel Stutzbach (untuk bermain golf) satu tahun yang lalu ketika ia menjadi sumber solusi tercepat saat itu (menyortir jaringan).

Linux 64 bit, gcc 4.6.1 64 bit, Intel Core 2 Duo E8400, -O2

• Panggilan langsung ke fungsi perpustakaan qsort: 689.38
• Implementasi naif (jenis penyisipan): 285.70
• Jenis Penyisipan (Daniel Stutzbach): 142.12
• Penyisipan Sortir Belum Terdaftar: 125,47
• Peringkat Pesanan: 102.26
• Urutan Peringkat dengan register: 58.03
• Penyortiran Jaringan (Daniel Stutzbach): 111.68
• Sorting Networks (Paul R): 66.36
• Sorting Networks 12 dengan Fast Swap: 58.86
• Sorting Networks 12 Swap dipesan ulang: 53.74
• Sorting Networks 12 Simple Swap yang disusun ulang: 31.54
• Reortered Sorting Network dengan swap cepat: 31.54
• Jaringan Penyortiran Reordered dengan swap cepat V2: 33.63
• Sortir Bubble Bergaris (Paolo Bonzini): 48.85
• Sortir Penyisipan Tidak Dikontrol (Paolo Bonzini): 75,30

Linux 64 bit, gcc 4.6.1 64 bit, Intel Core 2 Duo E8400, -O1

• Panggilan langsung ke fungsi perpustakaan qsort: 705.93
• Implementasi naif (jenis penyisipan): 135.60
• Jenis Penyisipan (Daniel Stutzbach): 142.11
• Penyisipan Sortir Belum Terdaftar: 126,75
• Peringkat Pesanan: 46,42
• Urutan Peringkat dengan register: 43,58
• Sorting Networks (Daniel Stutzbach): 115.57
• Sorting Networks (Paul R): 64.44
• Sorting Networks 12 dengan Fast Swap: 61.98
• Sorting Networks 12 Swap yang disusun ulang: 54.67
• Sorting Networks 12 Simple Swap yang disusun ulang: 31.54
• Jaringan Penyortiran Reordered dengan swap cepat: 31.24
• Reortered Sorting Network dengan swap cepat V2: 33.07
• Sortir Bubble Bergaris (Paolo Bonzini): 45,79
• Sortir Penyisipan Tidak Dikontrol (Paolo Bonzini): 80.15

Saya menyertakan hasil -O1 dan -O2 karena secara mengejutkan untuk beberapa program O2 kurang efisien daripada O1. Saya ingin tahu pengoptimalan spesifik apa yang memiliki efek ini?

Komentar tentang solusi yang diusulkan

Jenis Penyisipan (Daniel Stutzbach)

Seperti yang diharapkan meminimalkan cabang memang ide yang bagus.

Sorting Networks (Daniel Stutzbach)

Lebih baik daripada jenis penyisipan. Saya bertanya-tanya apakah efek utama tidak didapat dari menghindari loop eksternal. Saya mencobanya dengan memasukkan penyisipan tanpa gulungan untuk memeriksa dan memang kita mendapatkan kira-kira angka yang sama (kode ada di sini ).

Sorting Networks (Paul R)

Yang terbaik sejauh ini. Kode aktual yang saya gunakan untuk menguji ada di sini . Belum tahu mengapa ini hampir dua kali lebih cepat dari implementasi jaringan penyortiran lainnya. Melewati parameter? Max cepat?

Sorting Networks 12 SWAP dengan Fast Swap

Seperti yang disarankan oleh Daniel Stutzbach, saya menggabungkan 12 jaringan sortir swap-nya dengan swap cepat tanpa cabang (kode ada di sini ). Ini memang lebih cepat, yang terbaik sejauh ini dengan margin kecil (sekitar 5%) seperti yang bisa diharapkan menggunakan 1 swap lebih sedikit.

Menarik juga untuk memperhatikan bahwa swap tanpa cabang tampaknya jauh (4 kali) kurang efisien daripada yang sederhana jika menggunakan arsitektur PPC.

Memanggil Perpustakaan qsort

Untuk memberikan titik referensi lain saya juga mencoba seperti yang disarankan untuk memanggil perpustakaan qsort (kode ada di sini ). Seperti yang diharapkan itu jauh lebih lambat: 10 hingga 30 kali lebih lambat ... seperti yang terlihat jelas dengan test suite baru, masalah utama tampaknya menjadi beban awal perpustakaan setelah panggilan pertama, dan membandingkan tidak begitu buruk dengan yang lain Versi: kapan. Itu hanya antara 3 dan 20 kali lebih lambat di Linux saya. Pada beberapa arsitektur yang digunakan untuk tes oleh orang lain tampaknya bahkan lebih cepat (saya benar-benar terkejut dengan yang itu, karena perpustakaan qsort menggunakan API yang lebih kompleks).

Urutan peringkat

Rex Kerr mengusulkan metode lain yang sama sekali berbeda: untuk setiap item array menghitung langsung posisi akhirnya. Ini efisien karena urutan peringkat komputasi tidak perlu cabang. Kelemahan dari metode ini adalah dibutuhkan tiga kali jumlah memori array (satu salinan array dan variabel untuk menyimpan urutan peringkat). Hasil kinerja sangat mengejutkan (dan menarik). Pada arsitektur referensi saya dengan OS 32 bit dan Intel Core2 Quad E8300, jumlah siklus sedikit di bawah 1000 (seperti jaringan sortir dengan branching swap). Tetapi ketika dikompilasi dan dieksekusi pada kotak 64 bit saya (Intel Core2 Duo) kinerjanya jauh lebih baik: itu menjadi yang tercepat sejauh ini. Saya akhirnya menemukan alasan sebenarnya. Kotak 32 bit saya menggunakan gcc 4.4.1 dan kotak 64bits saya gcc 4.4.

perbarui :

Seperti gambar yang diterbitkan di atas menunjukkan efek ini masih ditingkatkan oleh versi gcc dan Urutan Peringkat kemudian secara konsisten dua kali lebih cepat dari alternatif lain.

Sorting Networks 12 dengan Swap yang disusun ulang

Efisiensi luar biasa dari proposal Rex Kerr dengan gcc 4.4.3 membuat saya bertanya-tanya: bagaimana mungkin sebuah program dengan penggunaan memori 3 kali lebih cepat dari pada jaringan sortir tanpa cabang? Hipotesis saya adalah bahwa ia memiliki sedikit ketergantungan dari jenis baca setelah menulis, memungkinkan untuk penggunaan yang lebih baik dari penjadwal instruksi superscalar x86. Itu memberi saya ide: mengatur ulang swap untuk meminimalkan membaca setelah menulis dependensi. Lebih sederhana: ketika Anda melakukannya, SWAP(1, 2); SWAP(0, 2);Anda harus menunggu swap pertama selesai sebelum melakukan yang kedua karena keduanya mengakses sel memori yang sama. Saat Anda melakukannya SWAP(1, 2); SWAP(4, 5);, prosesor dapat menjalankan keduanya secara paralel. Saya mencobanya dan berfungsi seperti yang diharapkan, jaringan sortasi berjalan sekitar 10% lebih cepat.

Sortasi Jaringan 12 dengan Simple Swap

Satu tahun setelah posting asli Steinar H. Gunderson menyarankan, bahwa kita tidak boleh mencoba mengakali kompiler dan menjaga kode swap sederhana. Ini memang ide yang bagus karena kode yang dihasilkan sekitar 40% lebih cepat! Dia juga mengusulkan swap yang dioptimalkan dengan tangan menggunakan kode perakitan inline x86 yang masih dapat meluangkan lebih banyak siklus. Yang paling mengejutkan (katanya volume pada psikologi programmer) adalah bahwa satu tahun yang lalu tidak ada yang digunakan mencoba versi swap. Kode yang saya gunakan untuk menguji ada di sini . Lainnya menyarankan cara lain untuk menulis swap cepat C, tetapi menghasilkan kinerja yang sama seperti yang sederhana dengan kompiler yang layak.

Kode "terbaik" sekarang adalah sebagai berikut:

static inline void sort6_sorting_network_simple_swap(int * d){
#define min(x, y) (x<y?x:y)
#define max(x, y) (x<y?y:x) 
#define SWAP(x,y) { const int a = min(d[x], d[y]); \
                    const int b = max(d[x], d[y]); \
                    d[x] = a; d[y] = b; }
    SWAP(1, 2);
    SWAP(4, 5);
    SWAP(0, 2);
    SWAP(3, 5);
    SWAP(0, 1);
    SWAP(3, 4);
    SWAP(1, 4);
    SWAP(0, 3);
    SWAP(2, 5);
    SWAP(1, 3);
    SWAP(2, 4);
    SWAP(2, 3);
#undef SWAP
#undef min
#undef max
}

Jika kami yakin set pengujian kami (dan, ya itu sangat buruk, itu hanya manfaatnya pendek, sederhana dan mudah untuk memahami apa yang kami ukur), jumlah rata-rata siklus kode yang dihasilkan untuk satu jenis adalah di bawah 40 siklus ( 6 tes dijalankan). Itu menempatkan setiap swap pada rata-rata 4 siklus. Saya menyebutnya sangat cepat. Adakah perbaikan lain yang mungkin?

Untuk optimasi apa pun, selalu terbaik untuk menguji, menguji, menguji. Saya akan mencoba setidaknya menyortir jaringan dan jenis penyisipan. Jika saya bertaruh, saya akan menaruh uang saya pada jenis penyisipan berdasarkan pengalaman masa lalu.

Apakah Anda tahu sesuatu tentang data input? Beberapa algoritma akan bekerja lebih baik dengan jenis data tertentu. Misalnya, penyisipan berkinerja lebih baik pada dat yang diurutkan atau hampir diurutkan, jadi itu akan menjadi pilihan yang lebih baik jika ada peluang di atas rata-rata data yang hampir diurutkan.

Algoritma yang Anda poskan mirip dengan jenis penyisipan, tetapi sepertinya Anda telah meminimalkan jumlah swap dengan biaya lebih banyak perbandingan. Namun, perbandingan jauh lebih mahal daripada swap, karena cabang dapat menyebabkan pipa instruksi terhenti.

Berikut ini adalah implementasi semacam penyisipan:

static __inline__ int sort6(int *d){
        int i, j;
        for (i = 1; i < 6; i++) {
                int tmp = d[i];
                for (j = i; j >= 1 && tmp < d[j-1]; j--)
                        d[j] = d[j-1];
                d[j] = tmp;
        }
}

Inilah cara saya membangun jaringan penyortiran. Pertama, gunakan situs ini untuk menghasilkan set minimal SWAP macro untuk jaringan dengan panjang yang sesuai. Membungkusnya dalam suatu fungsi memberi saya:

static __inline__ int sort6(int * d){
#define SWAP(x,y) if (d[y] < d[x]) { int tmp = d[x]; d[x] = d[y]; d[y] = tmp; }
    SWAP(1, 2);
    SWAP(0, 2);
    SWAP(0, 1);
    SWAP(4, 5);
    SWAP(3, 5);
    SWAP(3, 4);
    SWAP(0, 3);
    SWAP(1, 4);
    SWAP(2, 5);
    SWAP(2, 4);
    SWAP(1, 3);
    SWAP(2, 3);
#undef SWAP
}

Berikut ini implementasi menggunakan jaringan penyortiran :

inline void Sort2(int *p0, int *p1)
{
    const int temp = min(*p0, *p1);
    *p1 = max(*p0, *p1);
    *p0 = temp;
}

inline void Sort3(int *p0, int *p1, int *p2)
{
    Sort2(p0, p1);
    Sort2(p1, p2);
    Sort2(p0, p1);
}

inline void Sort4(int *p0, int *p1, int *p2, int *p3)
{
    Sort2(p0, p1);
    Sort2(p2, p3);
    Sort2(p0, p2);  
    Sort2(p1, p3);  
    Sort2(p1, p2);  
}

inline void Sort6(int *p0, int *p1, int *p2, int *p3, int *p4, int *p5)
{
    Sort3(p0, p1, p2);
    Sort3(p3, p4, p5);
    Sort2(p0, p3);  
    Sort2(p2, p5);  
    Sort4(p1, p2, p3, p4);  
}

Anda benar-benar membutuhkan percabangan mindan maximplementasi yang sangat efisien untuk ini, karena itulah yang secara efektif didasari oleh kode ini - suatu urutan mindan maxoperasi (total masing-masing 13). Saya meninggalkan ini sebagai latihan untuk pembaca.

Perhatikan bahwa implementasi ini cocok untuk vektorisasi (mis. SIMD - sebagian besar SIMD ISA memiliki petunjuk vektor / maks) dan juga untuk implementasi GPU (mis. CUDA - karena tanpa cabang tidak ada masalah dengan perbedaan warp dll).

Lihat juga: Implementasi algoritma cepat untuk mengurutkan daftar yang sangat kecil

Karena ini adalah bilangan bulat dan perbandingannya cepat, mengapa tidak menghitung urutan peringkat masing-masing secara langsung:

inline void sort6(int *d) {
  int e[6];
  memcpy(e,d,6*sizeof(int));
  int o0 = (d[0]>d[1])+(d[0]>d[2])+(d[0]>d[3])+(d[0]>d[4])+(d[0]>d[5]);
  int o1 = (d[1]>=d[0])+(d[1]>d[2])+(d[1]>d[3])+(d[1]>d[4])+(d[1]>d[5]);
  int o2 = (d[2]>=d[0])+(d[2]>=d[1])+(d[2]>d[3])+(d[2]>d[4])+(d[2]>d[5]);
  int o3 = (d[3]>=d[0])+(d[3]>=d[1])+(d[3]>=d[2])+(d[3]>d[4])+(d[3]>d[5]);
  int o4 = (d[4]>=d[0])+(d[4]>=d[1])+(d[4]>=d[2])+(d[4]>=d[3])+(d[4]>d[5]);
  int o5 = 15-(o0+o1+o2+o3+o4);
  d[o0]=e[0]; d[o1]=e[1]; d[o2]=e[2]; d[o3]=e[3]; d[o4]=e[4]; d[o5]=e[5];
}

Sepertinya saya terlambat ke pesta setahun, tapi kita mulai ...

Melihat perakitan yang dihasilkan oleh gcc 4.5.2 saya mengamati bahwa banyak dan toko sedang dilakukan untuk setiap swap, yang sebenarnya tidak diperlukan. Akan lebih baik untuk memuat 6 nilai ke dalam register, mengurutkannya, dan menyimpannya kembali ke dalam memori. Saya memesan muatan di toko sedekat mungkin ke sana register pertama kali diperlukan dan terakhir digunakan. Saya juga menggunakan makro SWAP Steinar H. Gunderson. Pembaruan: Saya beralih ke makro SWAP Paolo Bonzini yang diubah oleh gcc menjadi sesuatu yang mirip dengan milik Gunderson, tetapi gcc dapat memesan instruksi dengan lebih baik karena tidak diberikan sebagai perakitan eksplisit.

Saya menggunakan urutan swap yang sama dengan jaringan swap yang dipesan ulang yang diberikan sebagai yang berkinerja terbaik, meskipun mungkin ada pemesanan yang lebih baik. Jika saya menemukan waktu lagi saya akan menghasilkan dan menguji banyak permutasi.

Saya mengubah kode pengujian untuk mempertimbangkan lebih dari 4000 array dan menunjukkan jumlah rata-rata siklus yang diperlukan untuk mengurutkan masing-masing. Pada i5-650 saya mendapatkan ~ 34,1 siklus / urut (menggunakan -O3), dibandingkan dengan jaringan pengurutan yang disusun ulang yang asli yang mendapatkan ~ 65,3 siklus / urut (menggunakan -O1, ketukan -O2 dan -O3).

#include <stdio.h>

static inline void sort6_fast(int * d) {
#define SWAP(x,y) { int dx = x, dy = y, tmp; tmp = x = dx < dy ? dx : dy; y ^= dx ^ tmp; }
    register int x0,x1,x2,x3,x4,x5;
    x1 = d[1];
    x2 = d[2];
    SWAP(x1, x2);
    x4 = d[4];
    x5 = d[5];
    SWAP(x4, x5);
    x0 = d[0];
    SWAP(x0, x2);
    x3 = d[3];
    SWAP(x3, x5);
    SWAP(x0, x1);
    SWAP(x3, x4);
    SWAP(x1, x4);
    SWAP(x0, x3);
    d[0] = x0;
    SWAP(x2, x5);
    d[5] = x5;
    SWAP(x1, x3);
    d[1] = x1;
    SWAP(x2, x4);
    d[4] = x4;
    SWAP(x2, x3);
    d[2] = x2;
    d[3] = x3;

#undef SWAP
#undef min
#undef max
}

static __inline__ unsigned long long rdtsc(void)
{
    unsigned long long int x;
    __asm__ volatile ("rdtsc; shlq $32, %%rdx; orq %%rdx, %0" : "=a" (x) : : "rdx");
    return x;
}

void ran_fill(int n, int *a) {
    static int seed = 76521;
    while (n--) *a++ = (seed = seed *1812433253 + 12345);
}

#define NTESTS 4096
int main() {
    int i;
    int d[6*NTESTS];
    ran_fill(6*NTESTS, d);

    unsigned long long cycles = rdtsc();
    for (i = 0; i < 6*NTESTS ; i+=6) {
        sort6_fast(d+i);
    }
    cycles = rdtsc() - cycles;
    printf("Time is %.2lf\n", (double)cycles/(double)NTESTS);

    for (i = 0; i < 6*NTESTS ; i+=6) {
        if (d[i+0] > d[i+1] || d[i+1] > d[i+2] || d[i+2] > d[i+3] || d[i+3] > d[i+4] || d[i+4] > d[i+5])
            printf("d%d : %d %d %d %d %d %d\n", i,
                    d[i+0], d[i+1], d[i+2],
                    d[i+3], d[i+4], d[i+5]);
    }
    return 0;
}

Saya mengubah modifikasi test suite untuk juga melaporkan jam per sort dan menjalankan lebih banyak tes (fungsi cmp diperbarui untuk menangani integer overflow juga), berikut adalah hasil pada beberapa arsitektur yang berbeda. Saya mencoba pengujian pada AMD cpu tetapi rdtsc tidak dapat diandalkan pada X6 1100T yang saya miliki.

Clarkdale (i5-650)
==================
Direct call to qsort library function      635.14   575.65   581.61   577.76   521.12
Naive implementation (insertion sort)      538.30   135.36   134.89   240.62   101.23
Insertion Sort (Daniel Stutzbach)          424.48   159.85   160.76   152.01   151.92
Insertion Sort Unrolled                    339.16   125.16   125.81   129.93   123.16
Rank Order                                 184.34   106.58   54.74    93.24    94.09
Rank Order with registers                  127.45   104.65   53.79    98.05    97.95
Sorting Networks (Daniel Stutzbach)        269.77   130.56   128.15   126.70   127.30
Sorting Networks (Paul R)                  551.64   103.20   64.57    73.68    73.51
Sorting Networks 12 with Fast Swap         321.74   61.61    63.90    67.92    67.76
Sorting Networks 12 reordered Swap         318.75   60.69    65.90    70.25    70.06
Reordered Sorting Network w/ fast swap     145.91   34.17    32.66    32.22    32.18

Kentsfield (Core 2 Quad)
========================
Direct call to qsort library function      870.01   736.39   723.39   725.48   721.85
Naive implementation (insertion sort)      503.67   174.09   182.13   284.41   191.10
Insertion Sort (Daniel Stutzbach)          345.32   152.84   157.67   151.23   150.96
Insertion Sort Unrolled                    316.20   133.03   129.86   118.96   105.06
Rank Order                                 164.37   138.32   46.29    99.87    99.81
Rank Order with registers                  115.44   116.02   44.04    116.04   116.03
Sorting Networks (Daniel Stutzbach)        230.35   114.31   119.15   110.51   111.45
Sorting Networks (Paul R)                  498.94   77.24    63.98    62.17    65.67
Sorting Networks 12 with Fast Swap         315.98   59.41    58.36    60.29    55.15
Sorting Networks 12 reordered Swap         307.67   55.78    51.48    51.67    50.74
Reordered Sorting Network w/ fast swap     149.68   31.46    30.91    31.54    31.58

Sandy Bridge (i7-2600k)
=======================
Direct call to qsort library function      559.97   451.88   464.84   491.35   458.11
Naive implementation (insertion sort)      341.15   160.26   160.45   154.40   106.54
Insertion Sort (Daniel Stutzbach)          284.17   136.74   132.69   123.85   121.77
Insertion Sort Unrolled                    239.40   110.49   114.81   110.79   117.30
Rank Order                                 114.24   76.42    45.31    36.96    36.73
Rank Order with registers                  105.09   32.31    48.54    32.51    33.29
Sorting Networks (Daniel Stutzbach)        210.56   115.68   116.69   107.05   124.08
Sorting Networks (Paul R)                  364.03   66.02    61.64    45.70    44.19
Sorting Networks 12 with Fast Swap         246.97   41.36    59.03    41.66    38.98
Sorting Networks 12 reordered Swap         235.39   38.84    47.36    38.61    37.29
Reordered Sorting Network w/ fast swap     115.58   27.23    27.75    27.25    26.54

Nehalem (Xeon E5640)
====================
Direct call to qsort library function      911.62   890.88   681.80   876.03   872.89
Naive implementation (insertion sort)      457.69   236.87   127.68   388.74   175.28
Insertion Sort (Daniel Stutzbach)          317.89   279.74   147.78   247.97   245.09
Insertion Sort Unrolled                    259.63   220.60   116.55   221.66   212.93
Rank Order                                 140.62   197.04   52.10    163.66   153.63
Rank Order with registers                  84.83    96.78    50.93    109.96   54.73
Sorting Networks (Daniel Stutzbach)        214.59   220.94   118.68   120.60   116.09
Sorting Networks (Paul R)                  459.17   163.76   56.40    61.83    58.69
Sorting Networks 12 with Fast Swap         284.58   95.01    50.66    53.19    55.47
Sorting Networks 12 reordered Swap         281.20   96.72    44.15    56.38    54.57
Reordered Sorting Network w/ fast swap     128.34   50.87    26.87    27.91    28.02

Saya menemukan pertanyaan ini dari Google beberapa hari yang lalu karena saya juga memiliki kebutuhan untuk dengan cepat mengurutkan array dengan panjang tetap 6 bilangan bulat. Namun dalam kasus saya, bilangan bulat saya hanya 8 bit (bukan 32) dan saya tidak memiliki persyaratan ketat hanya menggunakan C. Saya pikir saya akan membagikan temuan saya, kalau-kalau mereka mungkin membantu seseorang ...

Saya menerapkan varian semacam jaringan dalam perakitan yang menggunakan SSE untuk membuat vektor operasi perbandingan dan swap, sejauh mungkin. Dibutuhkan enam "melewati" untuk sepenuhnya mengurutkan array. Saya menggunakan mekanisme baru untuk secara langsung mengkonversi hasil PCMPGTB (perbandingan vektor) menjadi parameter acak untuk PSHUFB (vectorized swap), hanya menggunakan PADDB (penambahan vektor) dan dalam beberapa kasus juga instruksi PAND (bitwise AND).

Pendekatan ini juga memiliki efek samping menghasilkan a benar fungsi yang cabang. Tidak ada instruksi lompatan sama sekali.

Tampaknya implementasi ini sekitar 38% lebih cepat daripada implementasi yang saat ini ditandai sebagai opsi tercepat dalam pertanyaan ("Menyortir Jaringan 12 dengan Simple Swap"). Saya memodifikasi implementasi itu untuk digunakanchar elemen array selama pengujian saya, untuk membuat perbandingan yang adil.

Saya harus mencatat bahwa pendekatan ini dapat diterapkan ke berbagai ukuran array hingga 16 elemen. Saya berharap keunggulan kecepatan relatif atas alternatif tumbuh lebih besar untuk array yang lebih besar.

Kode ini ditulis dalam MASM untuk prosesor x86_64 dengan SSSE3. Fungsi ini menggunakan konvensi pemanggilan Windows x64 "baru". Ini dia...

PUBLIC simd_sort_6

.DATA

ALIGN 16

pass1_shuffle   OWORD   0F0E0D0C0B0A09080706040503010200h
pass1_add       OWORD   0F0E0D0C0B0A09080706050503020200h
pass2_shuffle   OWORD   0F0E0D0C0B0A09080706030405000102h
pass2_and       OWORD   00000000000000000000FE00FEFE00FEh
pass2_add       OWORD   0F0E0D0C0B0A09080706050405020102h
pass3_shuffle   OWORD   0F0E0D0C0B0A09080706020304050001h
pass3_and       OWORD   00000000000000000000FDFFFFFDFFFFh
pass3_add       OWORD   0F0E0D0C0B0A09080706050404050101h
pass4_shuffle   OWORD   0F0E0D0C0B0A09080706050100020403h
pass4_and       OWORD   0000000000000000000000FDFD00FDFDh
pass4_add       OWORD   0F0E0D0C0B0A09080706050403020403h
pass5_shuffle   OWORD   0F0E0D0C0B0A09080706050201040300h
pass5_and       OWORD 0000000000000000000000FEFEFEFE00h
pass5_add       OWORD   0F0E0D0C0B0A09080706050403040300h
pass6_shuffle   OWORD   0F0E0D0C0B0A09080706050402030100h
pass6_add       OWORD   0F0E0D0C0B0A09080706050403030100h

.CODE

simd_sort_6 PROC FRAME

    .endprolog

    ; pxor xmm4, xmm4
    ; pinsrd xmm4, dword ptr [rcx], 0
    ; pinsrb xmm4, byte ptr [rcx + 4], 4
    ; pinsrb xmm4, byte ptr [rcx + 5], 5
    ; The benchmarked 38% faster mentioned in the text was with the above slower sequence that tied up the shuffle port longer.  Same on extract
    ; avoiding pins/extrb also means we don't need SSE 4.1, but SSSE3 CPUs without SSE4.1 (e.g. Conroe/Merom) have slow pshufb.
    movd    xmm4, dword ptr [rcx]
    pinsrw  xmm4,  word ptr [rcx + 4], 2  ; word 2 = bytes 4 and 5


    movdqa xmm5, xmm4
    pshufb xmm5, oword ptr [pass1_shuffle]
    pcmpgtb xmm5, xmm4
    paddb xmm5, oword ptr [pass1_add]
    pshufb xmm4, xmm5

    movdqa xmm5, xmm4
    pshufb xmm5, oword ptr [pass2_shuffle]
    pcmpgtb xmm5, xmm4
    pand xmm5, oword ptr [pass2_and]
    paddb xmm5, oword ptr [pass2_add]
    pshufb xmm4, xmm5

    movdqa xmm5, xmm4
    pshufb xmm5, oword ptr [pass3_shuffle]
    pcmpgtb xmm5, xmm4
    pand xmm5, oword ptr [pass3_and]
    paddb xmm5, oword ptr [pass3_add]
    pshufb xmm4, xmm5

    movdqa xmm5, xmm4
    pshufb xmm5, oword ptr [pass4_shuffle]
    pcmpgtb xmm5, xmm4
    pand xmm5, oword ptr [pass4_and]
    paddb xmm5, oword ptr [pass4_add]
    pshufb xmm4, xmm5

    movdqa xmm5, xmm4
    pshufb xmm5, oword ptr [pass5_shuffle]
    pcmpgtb xmm5, xmm4
    pand xmm5, oword ptr [pass5_and]
    paddb xmm5, oword ptr [pass5_add]
    pshufb xmm4, xmm5

    movdqa xmm5, xmm4
    pshufb xmm5, oword ptr [pass6_shuffle]
    pcmpgtb xmm5, xmm4
    paddb xmm5, oword ptr [pass6_add]
    pshufb xmm4, xmm5

    ;pextrd dword ptr [rcx], xmm4, 0    ; benchmarked with this
    ;pextrb byte ptr [rcx + 4], xmm4, 4 ; slower version
    ;pextrb byte ptr [rcx + 5], xmm4, 5
    movd   dword ptr [rcx], xmm4
    pextrw  word ptr [rcx + 4], xmm4, 2  ; x86 is little-endian, so this is the right order

    ret

simd_sort_6 ENDP

END

Anda dapat mengkompilasi ini ke objek yang dapat dieksekusi dan menautkannya ke proyek C. Untuk instruksi tentang cara melakukan ini di Visual Studio, Anda dapat membaca artikel ini . Anda dapat menggunakan prototipe C berikut untuk memanggil fungsi dari kode C Anda:

void simd_sort_6(char *values);

Kode tes sangat buruk; itu melebihi array awal (bukankah orang-orang di sini membaca peringatan kompiler?), printf mencetak elemen yang salah, ia menggunakan .byte untuk rdtsc tanpa alasan yang bagus, hanya ada satu run (!), tidak ada yang memeriksa bahwa hasil akhirnya sebenarnya benar (sehingga sangat mudah untuk "mengoptimalkan" menjadi sesuatu yang agak salah), tes yang disertakan sangat sederhana (tidak ada angka negatif?) dan tidak ada yang menghentikan kompiler dari hanya membuang seluruh fungsi sebagai kode mati.

Yang sedang berkata, itu juga cukup mudah untuk meningkatkan pada solusi jaringan bitonic; cukup ubah item min / max / SWAP ke

#define SWAP(x,y) { int tmp; asm("mov %0, %2 ; cmp %1, %0 ; cmovg %1, %0 ; cmovg %2, %1" : "=r" (d[x]), "=r" (d[y]), "=r" (tmp) : "0" (d[x]), "1" (d[y]) : "cc"); }

dan itu keluar sekitar 65% lebih cepat untuk saya (Debian gcc 4.4.5 dengan -O2, amd64, Core i7).

Sementara saya sangat suka swap makro yang disediakan:

#define min(x, y) (y ^ ((x ^ y) & -(x < y)))
#define max(x, y) (x ^ ((x ^ y) & -(x < y)))
#define SWAP(x,y) { int tmp = min(d[x], d[y]); d[y] = max(d[x], d[y]); d[x] = tmp; }

Saya melihat peningkatan (yang mungkin dilakukan oleh kompiler yang baik):

#define SWAP(x,y) { int tmp = ((x ^ y) & -(y < x)); y ^= tmp; x ^= tmp; }

Kami mencatat cara kerja min dan max dan menarik sub-ekspresi umum secara eksplisit. Ini menghilangkan makro min dan maks sepenuhnya.

Jangan pernah mengoptimalkan min / maks tanpa pembandingan dan melihat perakitan yang dihasilkan kompiler yang sebenarnya. Jika saya membiarkan GCC mengoptimalkan min dengan instruksi pemindahan bersyarat, saya mendapatkan peningkatan kecepatan 33%:

#define SWAP(x,y) { int dx = d[x], dy = d[y], tmp; tmp = d[x] = dx < dy ? dx : dy; d[y] ^= dx ^ tmp; }

(280 vs 420 siklus dalam kode tes). Melakukan maks dengan?: Kurang lebih sama, hampir hilang dalam kebisingan, tetapi di atas sedikit lebih cepat. SWAP ini lebih cepat dengan GCC dan Dentang.

Compiler juga melakukan pekerjaan luar biasa pada alokasi register dan analisis alias, secara efektif memindahkan d [x] ke variabel lokal dimuka, dan hanya menyalin kembali ke memori di akhir. Bahkan, mereka melakukannya bahkan lebih baik daripada jika Anda bekerja sepenuhnya dengan variabel lokal (sepertid0 = d[0], d1 = d[1], d2 = d[2], d3 = d[3], d4 = d[4], d5 = d[5] ). Saya menulis ini karena Anda mengasumsikan optimasi yang kuat dan belum mencoba mengakali kompiler pada min / max. :)

Omong-omong, saya mencoba Dentang dan GCC. Mereka melakukan optimasi yang sama, tetapi karena perbedaan penjadwalan keduanya memiliki beberapa variasi dalam hasil, tidak bisa mengatakan yang mana yang lebih cepat atau lebih lambat. GCC lebih cepat pada jaringan sortir, dentang jenis kuadratik.

Hanya untuk kelengkapan, jenis gelembung yang tidak terbuka dan jenis sisipan juga dimungkinkan. Ini adalah semacam gelembung:

SWAP(0,1); SWAP(1,2); SWAP(2,3); SWAP(3,4); SWAP(4,5);
SWAP(0,1); SWAP(1,2); SWAP(2,3); SWAP(3,4);
SWAP(0,1); SWAP(1,2); SWAP(2,3);
SWAP(0,1); SWAP(1,2);
SWAP(0,1);

dan ini adalah jenis sisipan:

//#define ITER(x) { if (t < d[x]) { d[x+1] = d[x]; d[x] = t; } }
//Faster on x86, probably slower on ARM or similar:
#define ITER(x) { d[x+1] ^= t < d[x] ? d[x] ^ d[x+1] : 0; d[x] = t < d[x] ? t : d[x]; }
static inline void sort6_insertion_sort_unrolled_v2(int * d){
    int t;
    t = d[1]; ITER(0);
    t = d[2]; ITER(1); ITER(0);
    t = d[3]; ITER(2); ITER(1); ITER(0);
    t = d[4]; ITER(3); ITER(2); ITER(1); ITER(0);
    t = d[5]; ITER(4); ITER(3); ITER(2); ITER(1); ITER(0);

Jenis penyisipan ini lebih cepat daripada milik Daniel Stutzbach, dan terutama bagus pada GPU atau komputer dengan predikasi karena ITER dapat dilakukan dengan hanya 3 instruksi (vs. 4 untuk SWAP). Sebagai contoh, inilah t = d[2]; ITER(1); ITER(0);baris dalam perakitan ARM:

    MOV    r6, r2
    CMP    r6, r1
    MOVLT  r2, r1
    MOVLT  r1, r6
    CMP    r6, r0
    MOVLT  r1, r0
    MOVLT  r0, r6

Untuk enam elemen, jenis penyisipan kompetitif dengan jaringan penyortiran (12 swap vs 15 iterasi saldo 4 instruksi / swap vs 3 instruksi / iterasi); semacam gelembung tentu saja lebih lambat. Tapi itu tidak akan menjadi kenyataan ketika ukurannya bertambah, karena jenis penyisipan adalah O (n ^ 2) sedangkan jaringan penyortiran adalah O (n log n).

Saya memindahkan test suite ke mesin arsitektur PPC yang tidak dapat saya identifikasi (tidak harus menyentuh kode, cukup tambahkan iterasi tes, gunakan 8 kasus uji untuk menghindari polusi hasil dengan mod dan ganti rdtsc spesifik x86):

Fungsi panggilan langsung ke perpustakaan qsort : 101

Implementasi naif (jenis penyisipan) : 299

Jenis Penyisipan (Daniel Stutzbach) : 108

Penyisipan Sortir Belum Terdaftar : 51

Sorting Networks (Daniel Stutzbach) : 26

Sorting Networks (Paul R) : 85

Sorting Networks 12 dengan Fast Swap : 117

Sorting Networks 12 Swap dipesan ulang : 116

Peringkat Pesanan : 56

Swap XOR mungkin berguna dalam fungsi swapping Anda.

void xorSwap (int *x, int *y) {
     if (*x != *y) {
         *x ^= *y;
         *y ^= *x;
         *x ^= *y;
     }
 }

Jika dapat menyebabkan terlalu banyak perbedaan dalam kode Anda, tetapi jika Anda memiliki jaminan bahwa semua int Anda unik, ini bisa berguna.

Melihat ke depan untuk mencoba tangan saya ini dan belajar dari contoh-contoh ini, tetapi pertama-tama beberapa waktu dari 1.5 GHz PPC Powerbook G4 w / 1 GB DDR RAM. (Saya meminjam timer mirip rdtsc untuk PPC dari http://www.mcs.anl.gov/~kazutomo/rdtsc.html untuk pengaturan waktu.) Saya menjalankan program beberapa kali dan hasil absolut bervariasi tetapi hasilnya konsisten tetapi konsisten tes tercepat adalah "Penyisipan Sortir (Daniel Stutzbach)", dengan "Penyisipan Sortir Tidak Terbuka" yang kedua.

Inilah rangkaian waktu terakhir:

**Direct call to qsort library function** : 164
**Naive implementation (insertion sort)** : 138
**Insertion Sort (Daniel Stutzbach)**     : 85
**Insertion Sort Unrolled**               : 97
**Sorting Networks (Daniel Stutzbach)**   : 457
**Sorting Networks (Paul R)**             : 179
**Sorting Networks 12 with Fast Swap**    : 238
**Sorting Networks 12 reordered Swap**    : 236
**Rank Order**                            : 116

Inilah kontribusi saya untuk utas ini: shellsort celah 1, 4 yang dioptimalkan untuk vektor int 6-anggota (valp) yang berisi nilai-nilai unik.

void shellsort (int *valp)
{      
  int c,a,*cp,*ip=valp,*ep=valp+5;

  c=*valp;    a=*(valp+4);if (c>a) {*valp=    a;*(valp+4)=c;}
  c=*(valp+1);a=*(valp+5);if (c>a) {*(valp+1)=a;*(valp+5)=c;}

  cp=ip;    
  do
  {
    c=*cp;
    a=*(cp+1);
    do
    {
      if (c<a) break;

      *cp=a;
      *(cp+1)=c;
      cp-=1;
      c=*cp;
    } while (cp>=valp);
    ip+=1;
    cp=ip;
  } while (ip<ep);
}

Pada laptop HP dv7-3010so saya dengan Athlon M300 @ 2 Ghz dual-core (memori DDR2) dijalankan dalam siklus 165 jam. Ini adalah rata-rata yang dihitung dari pengaturan waktu setiap urutan unik (6! / 720 semuanya). Dikompilasi ke Win32 menggunakan OpenWatcom 1.8. Loop pada dasarnya adalah jenis penyisipan dan panjangnya 16 instruksi / 37 byte.

Saya tidak memiliki lingkungan 64-bit untuk dikompilasi.

Jika jenis penyisipan cukup kompetitif di sini, saya akan merekomendasikan mencoba shellsort. Saya khawatir 6 elemen mungkin terlalu sedikit untuk menjadi yang terbaik, tetapi mungkin patut dicoba.

Contoh kode, belum diuji, undebugged, dll. Anda ingin menyetel urutan inc = 4 dan inc - = 3 untuk menemukan yang optimal (coba inc = 2, inc - = 1 misalnya).

static __inline__ int sort6(int * d) {
    char j, i;
    int tmp;
    for (inc = 4; inc > 0; inc -= 3) {
        for (i = inc; i < 5; i++) {
            tmp = a[i];
            j = i;
            while (j >= inc && a[j - inc] > tmp) {
                a[j] = a[j - inc];
                j -= inc;
            }
            a[j] = tmp;
        }
    }
}

Saya tidak berpikir ini akan menang, tetapi jika seseorang memposting pertanyaan tentang menyortir 10 elemen, siapa tahu ...

Menurut Wikipedia ini bahkan dapat dikombinasikan dengan jaringan sortir: Pratt, V (1979). Shellsort dan jaringan sortir (Disertasi luar biasa dalam ilmu komputer). Karangan bunga. ISBN 0-824-04406-1

Saya tahu saya sangat terlambat, tetapi saya tertarik untuk bereksperimen dengan beberapa solusi yang berbeda. Pertama, saya membersihkan pasta itu, membuatnya mengkompilasi, dan memasukkannya ke dalam repositori. Saya menyimpan beberapa solusi yang tidak diinginkan sebagai jalan buntu sehingga yang lain tidak akan mencobanya. Di antara ini adalah solusi pertama saya, yang berusaha memastikan bahwa x1> x2 dihitung sekali. Setelah optimasi, tidak lebih cepat dari versi sederhana lainnya.

Saya menambahkan versi pengulangan urutan urutan peringkat, karena aplikasi saya sendiri dari penelitian ini adalah untuk mengurutkan 2-8 item, jadi karena ada sejumlah variabel argumen, diperlukan loop. Ini juga mengapa saya mengabaikan solusi jaringan penyortiran.

Kode tes tidak menguji bahwa duplikat ditangani dengan benar, jadi sementara solusi yang ada semuanya benar, saya menambahkan kasus khusus pada kode pengujian untuk memastikan bahwa duplikat ditangani dengan benar.

Kemudian, saya menulis semacam sisipan yang seluruhnya ada di register AVX. Pada mesin saya, 25% lebih cepat dari jenis insersi lainnya, tetapi 100% lebih lambat dari urutan peringkat. Saya melakukan ini murni untuk percobaan dan tidak memiliki harapan ini menjadi lebih baik karena percabangan dalam jenis penyisipan.

static inline void sort6_insertion_sort_avx(int* d) {
    __m256i src = _mm256_setr_epi32(d[0], d[1], d[2], d[3], d[4], d[5], 0, 0);
    __m256i index = _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
    __m256i shlpermute = _mm256_setr_epi32(7, 0, 1, 2, 3, 4, 5, 6);
    __m256i sorted = _mm256_setr_epi32(d[0], INT_MAX, INT_MAX, INT_MAX,
            INT_MAX, INT_MAX, INT_MAX, INT_MAX);
    __m256i val, gt, permute;
    unsigned j;
     // 8 / 32 = 2^-2
#define ITER(I) \
        val = _mm256_permutevar8x32_epi32(src, _mm256_set1_epi32(I));\
        gt =  _mm256_cmpgt_epi32(sorted, val);\
        permute =  _mm256_blendv_epi8(index, shlpermute, gt);\
        j = ffs( _mm256_movemask_epi8(gt)) >> 2;\
        sorted = _mm256_blendv_epi8(_mm256_permutevar8x32_epi32(sorted, permute),\
                val, _mm256_cmpeq_epi32(index, _mm256_set1_epi32(j)))
    ITER(1);
    ITER(2);
    ITER(3);
    ITER(4);
    ITER(5);
    int x[8];
    _mm256_storeu_si256((__m256i*)x, sorted);
    d[0] = x[0]; d[1] = x[1]; d[2] = x[2]; d[3] = x[3]; d[4] = x[4]; d[5] = x[5];
#undef ITER
}

Kemudian, saya menulis semacam urutan peringkat menggunakan AVX. Ini cocok dengan kecepatan solusi urutan-peringkat lainnya, tetapi tidak lebih cepat. Masalahnya di sini adalah saya hanya bisa menghitung indeks dengan AVX, dan kemudian saya harus membuat tabel indeks. Ini karena perhitungannya berbasis tujuan daripada berbasis sumber. Lihat Mengubah dari Indeks Berbasis Sumber ke Indeks Berbasis Destinasi

static inline void sort6_rank_order_avx(int* d) {
    __m256i ror = _mm256_setr_epi32(5, 0, 1, 2, 3, 4, 6, 7);
    __m256i one = _mm256_set1_epi32(1);
    __m256i src = _mm256_setr_epi32(d[0], d[1], d[2], d[3], d[4], d[5], INT_MAX, INT_MAX);
    __m256i rot = src;
    __m256i index = _mm256_setzero_si256();
    __m256i gt, permute;
    __m256i shl = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 6, 6);
    __m256i dstIx = _mm256_setr_epi32(0,1,2,3,4,5,6,7);
    __m256i srcIx = dstIx;
    __m256i eq = one;
    __m256i rotIx = _mm256_setzero_si256();
#define INC(I)\
    rot = _mm256_permutevar8x32_epi32(rot, ror);\
    gt = _mm256_cmpgt_epi32(src, rot);\
    index = _mm256_add_epi32(index, _mm256_and_si256(gt, one));\
    index = _mm256_add_epi32(index, _mm256_and_si256(eq,\
                _mm256_cmpeq_epi32(src, rot)));\
    eq = _mm256_insert_epi32(eq, 0, I)
    INC(0);
    INC(1);
    INC(2);
    INC(3);
    INC(4);
    int e[6];
    e[0] = d[0]; e[1] = d[1]; e[2] = d[2]; e[3] = d[3]; e[4] = d[4]; e[5] = d[5];
    int i[8];
    _mm256_storeu_si256((__m256i*)i, index);
    d[i[0]] = e[0]; d[i[1]] = e[1]; d[i[2]] = e[2]; d[i[3]] = e[3]; d[i[4]] = e[4]; d[i[5]] = e[5];
}

Repo dapat ditemukan di sini: https://github.com/eyepatchParrot/sort6/

Pertanyaan ini menjadi cukup lama, tetapi saya benar-benar harus menyelesaikan masalah yang sama hari ini: agoritma cepat untuk mengurutkan array kecil. Saya pikir itu akan menjadi ide yang baik untuk membagikan pengetahuan saya. Ketika saya pertama kali mulai dengan menggunakan jaringan penyortiran, saya akhirnya berhasil menemukan algoritma lain yang jumlah perbandingan dilakukan untuk mengurutkan setiap permutasi dari 6 nilai lebih kecil dari dengan jaringan penyortiran, dan lebih kecil dari dengan penyisipan jenis. Saya tidak menghitung jumlah swap; Saya kira kira-kira setara (mungkin kadang-kadang sedikit lebih tinggi).

Algoritma sort6menggunakan algoritma sort4yang menggunakan algoritma sort3. Berikut ini adalah implementasi dalam beberapa bentuk C ++ ringan (aslinya adalah template-berat sehingga dapat bekerja dengan iterator akses-acak dan fungsi perbandingan yang sesuai).

Menyortir 3 nilai

Algoritme berikut adalah jenis penyisipan yang tidak digulung. Ketika dua swap (6 penugasan) harus dilakukan, ia menggunakan 4 penugasan sebagai gantinya:

void sort3(int* array)
{
    if (array[1] < array[0]) {
        if (array[2] < array[0]) {
            if (array[2] < array[1]) {
                std::swap(array[0], array[2]);
            } else {
                int tmp = array[0];
                array[0] = array[1];
                array[1] = array[2];
                array[2] = tmp;
            }
        } else {
            std::swap(array[0], array[1]);
        }
    } else {
        if (array[2] < array[1]) {
            if (array[2] < array[0]) {
                int tmp = array[2];
                array[2] = array[1];
                array[1] = array[0];
                array[0] = tmp;
            } else {
                std::swap(array[1], array[2]);
            }
        }
    }
}

Itu terlihat agak rumit karena pengurutan memiliki lebih atau kurang satu cabang untuk setiap permutasi yang mungkin dari array, menggunakan 2 ~ 3 perbandingan dan paling banyak 4 penugasan untuk mengurutkan ketiga nilai.

Mengurutkan 4 nilai

Panggilan yang satu ini sort3kemudian melakukan jenis penyisipan yang tidak terbuka dengan elemen terakhir dari array:

void sort4(int* array)
{
    // Sort the first 3 elements
    sort3(array);

    // Insert the 4th element with insertion sort 
    if (array[3] < array[2]) {
        std::swap(array[2], array[3]);
        if (array[2] < array[1]) {
            std::swap(array[1], array[2]);
            if (array[1] < array[0]) {
                std::swap(array[0], array[1]);
            }
        }
    }
}

Algoritma ini melakukan perbandingan 3 hingga 6 dan paling banyak 5 swap. Sangat mudah untuk membuka gulungan jenis penyisipan, tetapi kami akan menggunakan algoritma lain untuk jenis yang terakhir ...

Mengurutkan 6 nilai

Yang ini menggunakan versi yang belum dibuka dari apa yang saya sebut semacam penyisipan ganda . Namanya tidak terlalu bagus, tapi cukup deskriptif, ini cara kerjanya:

• Urutkan semuanya kecuali elemen pertama dan terakhir dari array.
• Tukar elemen pertama dan elemen array jika yang pertama lebih besar dari yang terakhir.
• Masukkan elemen pertama ke dalam urutan yang diurutkan dari depan lalu elemen terakhir dari belakang.

Setelah swap, elemen pertama selalu lebih kecil dari yang terakhir, yang berarti bahwa, ketika memasukkannya ke dalam urutan yang diurutkan, tidak akan ada lebih dari perbandingan N untuk memasukkan dua elemen dalam kasus terburuk: misalnya, jika elemen pertama telah disisipkan di posisi ke-3, maka yang terakhir tidak dapat disisipkan lebih rendah dari posisi ke-4.

void sort6(int* array)
{
    // Sort everything but first and last elements
    sort4(array+1);

    // Switch first and last elements if needed
    if (array[5] < array[0]) {
        std::swap(array[0], array[5]);
    }

    // Insert first element from the front
    if (array[1] < array[0]) {
        std::swap(array[0], array[1]);
        if (array[2] < array[1]) {
            std::swap(array[1], array[2]);
            if (array[3] < array[2]) {
                std::swap(array[2], array[3]);
                if (array[4] < array[3]) {
                    std::swap(array[3], array[4]);
                }
            }
        }
    }

    // Insert last element from the back
    if (array[5] < array[4]) {
        std::swap(array[4], array[5]);
        if (array[4] < array[3]) {
            std::swap(array[3], array[4]);
            if (array[3] < array[2]) {
                std::swap(array[2], array[3]);
                if (array[2] < array[1]) {
                    std::swap(array[1], array[2]);
                }
            }
        }
    }
}

Pengujian saya pada setiap permutasi 6 nilai pernah menunjukkan bahwa algoritma ini selalu melakukan perbandingan antara 6 dan 13. Saya tidak menghitung jumlah swap yang dilakukan, tetapi saya tidak berharap itu lebih tinggi dari 11 dalam kasus terburuk.

Saya harap ini membantu, walaupun pertanyaan ini mungkin tidak mewakili masalah aktual :)

EDIT: setelah meletakkannya di patokan yang disediakan, itu lebih lambat lebih lambat daripada kebanyakan alternatif yang menarik. Ini cenderung melakukan sedikit lebih baik daripada jenis penyisipan yang tidak gulungan, tapi cukup banyak. Pada dasarnya, ini bukan jenis terbaik untuk bilangan bulat tetapi bisa menarik untuk jenis dengan operasi perbandingan yang mahal.

Saya percaya ada dua bagian dari pertanyaan Anda.

• Yang pertama adalah menentukan algoritma yang optimal. Hal ini dilakukan - setidaknya dalam kasus ini - dengan mengulangi setiap pemesanan yang mungkin (tidak ada banyak) yang memungkinkan Anda untuk menghitung min, maks, rata-rata dan standar deviasi dari perbandingan dan swap. Siapkan juga satu atau dua runner-up.
• Yang kedua adalah mengoptimalkan algoritma. Banyak yang bisa dilakukan untuk mengonversi contoh kode buku teks menjadi mean dan bersandar pada algoritma kehidupan nyata. Jika Anda menyadari bahwa suatu algoritma tidak dapat dioptimalkan sejauh yang diperlukan, cobalah runner-up.

Saya tidak akan terlalu khawatir tentang mengosongkan pipa (dengan asumsi x86 saat ini): prediksi cabang telah jauh. Yang saya khawatirkan adalah memastikan bahwa kode dan data sesuai dalam satu baris cache masing-masing (mungkin dua untuk kode). Setelah mengambil latensi rendah menyegarkan yang akan mengimbangi kios apa pun. Ini juga berarti bahwa loop batin Anda mungkin sekitar sepuluh instruksi atau lebih yang benar di mana seharusnya (ada dua loop batin yang berbeda dalam algoritma pengurutan saya, mereka masing-masing 10 instruksi / 22 byte dan 9/22 panjang). Dengan asumsi kode tidak mengandung div, Anda dapat yakin itu akan sangat cepat.

Saya tahu ini adalah pertanyaan lama.

Tetapi saya hanya menulis solusi berbeda yang ingin saya bagikan.
Menggunakan apa-apa selain MIN MAX bersarang,

Ini tidak cepat karena menggunakan 114 masing-masing,
bisa menguranginya menjadi 75 cukup sederhana seperti -> pastebin

Tapi kemudian itu bukan min max lagi.

Yang mungkin berhasil adalah melakukan min / max pada banyak integer sekaligus dengan AVX

Referensi PMINSW

#include <stdio.h>

static __inline__ int MIN(int a, int b){
int result =a;
__asm__ ("pminsw %1, %0" : "+x" (result) : "x" (b));
return result;
}
static __inline__ int MAX(int a, int b){
int result = a;
__asm__ ("pmaxsw %1, %0" : "+x" (result) : "x" (b));
return result;
}
static __inline__ unsigned long long rdtsc(void){
  unsigned long long int x;
__asm__ volatile (".byte 0x0f, 0x31" :
  "=A" (x));
  return x;
}

#define MIN3(a, b, c) (MIN(MIN(a,b),c))
#define MIN4(a, b, c, d) (MIN(MIN(a,b),MIN(c,d)))

static __inline__ void sort6(int * in) {
  const int A=in[0], B=in[1], C=in[2], D=in[3], E=in[4], F=in[5];

  in[0] = MIN( MIN4(A,B,C,D),MIN(E,F) );

  const int
  AB = MAX(A, B),
  AC = MAX(A, C),
  AD = MAX(A, D),
  AE = MAX(A, E),
  AF = MAX(A, F),
  BC = MAX(B, C),
  BD = MAX(B, D),
  BE = MAX(B, E),
  BF = MAX(B, F),
  CD = MAX(C, D),
  CE = MAX(C, E),
  CF = MAX(C, F),
  DE = MAX(D, E),
  DF = MAX(D, F),
  EF = MAX(E, F);

  in[1] = MIN4 (
  MIN4( AB, AC, AD, AE ),
  MIN4( AF, BC, BD, BE ),
  MIN4( BF, CD, CE, CF ),
  MIN3( DE, DF, EF)
  );

  const int
  ABC = MAX(AB,C),
  ABD = MAX(AB,D),
  ABE = MAX(AB,E),
  ABF = MAX(AB,F),
  ACD = MAX(AC,D),
  ACE = MAX(AC,E),
  ACF = MAX(AC,F),
  ADE = MAX(AD,E),
  ADF = MAX(AD,F),
  AEF = MAX(AE,F),
  BCD = MAX(BC,D),
  BCE = MAX(BC,E),
  BCF = MAX(BC,F),
  BDE = MAX(BD,E),
  BDF = MAX(BD,F),
  BEF = MAX(BE,F),
  CDE = MAX(CD,E),
  CDF = MAX(CD,F),
  CEF = MAX(CE,F),
  DEF = MAX(DE,F);

  in[2] = MIN( MIN4 (
  MIN4( ABC, ABD, ABE, ABF ),
  MIN4( ACD, ACE, ACF, ADE ),
  MIN4( ADF, AEF, BCD, BCE ),
  MIN4( BCF, BDE, BDF, BEF )),
  MIN4( CDE, CDF, CEF, DEF )
  );


  const int
  ABCD = MAX(ABC,D),
  ABCE = MAX(ABC,E),
  ABCF = MAX(ABC,F),
  ABDE = MAX(ABD,E),
  ABDF = MAX(ABD,F),
  ABEF = MAX(ABE,F),
  ACDE = MAX(ACD,E),
  ACDF = MAX(ACD,F),
  ACEF = MAX(ACE,F),
  ADEF = MAX(ADE,F),
  BCDE = MAX(BCD,E),
  BCDF = MAX(BCD,F),
  BCEF = MAX(BCE,F),
  BDEF = MAX(BDE,F),
  CDEF = MAX(CDE,F);

  in[3] = MIN4 (
  MIN4( ABCD, ABCE, ABCF, ABDE ),
  MIN4( ABDF, ABEF, ACDE, ACDF ),
  MIN4( ACEF, ADEF, BCDE, BCDF ),
  MIN3( BCEF, BDEF, CDEF )
  );

  const int
  ABCDE= MAX(ABCD,E),
  ABCDF= MAX(ABCD,F),
  ABCEF= MAX(ABCE,F),
  ABDEF= MAX(ABDE,F),
  ACDEF= MAX(ACDE,F),
  BCDEF= MAX(BCDE,F);

  in[4]= MIN (
  MIN4( ABCDE, ABCDF, ABCEF, ABDEF ),
  MIN ( ACDEF, BCDEF )
  );

  in[5] = MAX(ABCDE,F);
}

int main(int argc, char ** argv) {
  int d[6][6] = {
    {1, 2, 3, 4, 5, 6},
    {6, 5, 4, 3, 2, 1},
    {100, 2, 300, 4, 500, 6},
    {100, 2, 3, 4, 500, 6},
    {1, 200, 3, 4, 5, 600},
    {1, 1, 2, 1, 2, 1}
  };

  unsigned long long cycles = rdtsc();
  for (int i = 0; i < 6; i++) {
    sort6(d[i]);
  }
  cycles = rdtsc() - cycles;
  printf("Time is %d\n", (unsigned)cycles);

  for (int i = 0; i < 6; i++) {
    printf("d%d : %d %d %d %d %d %d\n", i,
     d[i][0], d[i][1], d[i][2],
     d[i][3], d[i][4], d[i][5]);
  }
}

EDIT:
Solusi urutan peringkat yang terinspirasi oleh Rex Kerr, Jauh lebih cepat daripada kekacauan di atas

static void sort6(int *o) {
const int 
A=o[0],B=o[1],C=o[2],D=o[3],E=o[4],F=o[5];
const unsigned char
AB = A>B, AC = A>C, AD = A>D, AE = A>E,
          BC = B>C, BD = B>D, BE = B>E,
                    CD = C>D, CE = C>E,
                              DE = D>E,
a =          AB + AC + AD + AE + (A>F),
b = 1 - AB      + BC + BD + BE + (B>F),
c = 2 - AC - BC      + CD + CE + (C>F),
d = 3 - AD - BD - CD      + DE + (D>F),
e = 4 - AE - BE - CE - DE      + (E>F);
o[a]=A; o[b]=B; o[c]=C; o[d]=D; o[e]=E;
o[15-a-b-c-d-e]=F;
}

Saya menemukan bahwa setidaknya pada sistem saya, fungsi sort6_iterator()dan sort6_iterator_local()definisi di bawah keduanya berjalan setidaknya secepat, dan seringkali terasa lebih cepat, daripada pemegang rekor saat ini di atas:

#define MIN(x, y) (x<y?x:y)
#define MAX(x, y) (x<y?y:x)

template<class IterType> 
inline void sort6_iterator(IterType it) 
{
#define SWAP(x,y) { const auto a = MIN(*(it + x), *(it + y)); \
  const auto b = MAX(*(it + x), *(it + y)); \
  *(it + x) = a; *(it + y) = b; }

  SWAP(1, 2) SWAP(4, 5)
  SWAP(0, 2) SWAP(3, 5)
  SWAP(0, 1) SWAP(3, 4)
  SWAP(1, 4) SWAP(0, 3)
  SWAP(2, 5) SWAP(1, 3)
  SWAP(2, 4)
  SWAP(2, 3)
#undef SWAP
}

Saya melewati fungsi ini sebagai std::vectorkode waktu saya.

Saya menduga (dari komentar seperti ini dan di tempat lain) bahwa menggunakan iterator memberi g ++ jaminan tertentu tentang apa yang dapat dan tidak dapat terjadi pada memori yang dirujuk oleh iterator, yang sebaliknya tidak dimiliki dan jaminan inilah yang memungkinkan g ++ untuk lebih baik mengoptimalkan kode penyortiran (misalnya dengan pointer, kompiler tidak dapat memastikan bahwa semua pointer menunjuk ke lokasi memori yang berbeda). Jika saya ingat dengan benar, ini juga merupakan bagian dari alasan mengapa banyak algoritma STL, sepertistd::sort() , umumnya memiliki kinerja yang sangat buruk.

Selain itu, sort6_iterator()adalah beberapa kali (sekali lagi, tergantung pada konteks di mana fungsi ini dipanggil) secara konsisten mengungguli oleh fungsi menyortir berikut, yang salinan data ke variabel lokal sebelum menyortir mereka. ¹ Perhatikan bahwa karena hanya ada 6 variabel lokal yang ditentukan, jika variabel lokal ini primitif maka kemungkinan besar mereka tidak pernah benar-benar disimpan dalam RAM dan sebaliknya hanya pernah disimpan dalam register CPU sampai akhir panggilan fungsi, yang membantu membuat penyortiran ini. berfungsi cepat. (Ini juga membantu bahwa kompiler mengetahui bahwa variabel lokal yang berbeda memiliki lokasi yang berbeda dalam memori).

template<class IterType> 
inline void sort6_iterator_local(IterType it) 
{
#define SWAP(x,y) { const auto a = MIN(data##x, data##y); \
  const auto b = MAX(data##x, data##y); \
  data##x = a; data##y = b; }
//DD = Define Data
#define DD1(a)   auto data##a = *(it + a);
#define DD2(a,b) auto data##a = *(it + a), data##b = *(it + b);
//CB = Copy Back
#define CB(a) *(it + a) = data##a;

  DD2(1,2)    SWAP(1, 2)
  DD2(4,5)    SWAP(4, 5)
  DD1(0)      SWAP(0, 2)
  DD1(3)      SWAP(3, 5)
  SWAP(0, 1)  SWAP(3, 4)
  SWAP(1, 4)  SWAP(0, 3)   CB(0)
  SWAP(2, 5)  CB(5)
  SWAP(1, 3)  CB(1)
  SWAP(2, 4)  CB(4)
  SWAP(2, 3)  CB(2)        CB(3)
#undef CB
#undef DD2
#undef DD1
#undef SWAP
}

Perhatikan bahwa mendefinisikan SWAP()sebagai berikut beberapa kali menghasilkan kinerja yang sedikit lebih baik meskipun sebagian besar waktu menghasilkan kinerja yang sedikit lebih buruk atau perbedaan kinerja yang dapat diabaikan.

#define SWAP(x,y) { const auto a = MIN(data##x, data##y); \
  data##y = MAX(data##x, data##y); \
  data##x = a; }

Jika Anda hanya menginginkan algoritma pengurutan yang pada tipe data primitif, gcc -O3 konsisten dalam mengoptimalkan tidak peduli apa pun konteks panggilan ke fungsi pengurutan muncul dalam ¹ lalu, tergantung pada bagaimana Anda mengirimkan input, coba salah satu dari dua berikut algoritma:

template<class T> inline void sort6(T it) {
#define SORT2(x,y) {if(data##x>data##y){auto a=std::move(data##y);data##y=std::move(data##x);data##x=std::move(a);}}
#define DD1(a)   register auto data##a=*(it+a);
#define DD2(a,b) register auto data##a=*(it+a);register auto data##b=*(it+b);
#define CB1(a)   *(it+a)=data##a;
#define CB2(a,b) *(it+a)=data##a;*(it+b)=data##b;
  DD2(1,2) SORT2(1,2)
  DD2(4,5) SORT2(4,5)
  DD1(0)   SORT2(0,2)
  DD1(3)   SORT2(3,5)
  SORT2(0,1) SORT2(3,4) SORT2(2,5) CB1(5)
  SORT2(1,4) SORT2(0,3) CB1(0)
  SORT2(2,4) CB1(4)
  SORT2(1,3) CB1(1)
  SORT2(2,3) CB2(2,3)
#undef CB1
#undef CB2
#undef DD1
#undef DD2
#undef SORT2
}

Atau jika Anda ingin meneruskan variabel dengan referensi, maka gunakan ini (fungsi di bawah ini berbeda dari yang di atas dalam 5 baris pertama):

template<class T> inline void sort6(T& e0, T& e1, T& e2, T& e3, T& e4, T& e5) {
#define SORT2(x,y) {if(data##x>data##y)std::swap(data##x,data##y);}
#define DD1(a)   register auto data##a=e##a;
#define DD2(a,b) register auto data##a=e##a;register auto data##b=e##b;
#define CB1(a)   e##a=data##a;
#define CB2(a,b) e##a=data##a;e##b=data##b;
  DD2(1,2) SORT2(1,2)
  DD2(4,5) SORT2(4,5)
  DD1(0)   SORT2(0,2)
  DD1(3)   SORT2(3,5)
  SORT2(0,1) SORT2(3,4) SORT2(2,5) CB1(5)
  SORT2(1,4) SORT2(0,3) CB1(0)
  SORT2(2,4) CB1(4)
  SORT2(1,3) CB1(1)
  SORT2(2,3) CB2(2,3)
#undef CB1
#undef CB2
#undef DD1
#undef DD2
#undef SORT2
}

Alasan menggunakan registerkata kunci adalah karena ini adalah salah satu dari beberapa kali Anda tahu bahwa Anda menginginkan nilai-nilai ini dalam register. Tanpa register, kompiler akan mencari tahu sebagian besar waktu tetapi kadang-kadang tidak. Menggunakan registerkata kunci membantu menyelesaikan masalah ini. Namun, biasanya, jangan gunakan registerkata kunci karena lebih cenderung memperlambat kode Anda daripada mempercepatnya.

Juga, perhatikan penggunaan template. Hal ini dilakukan dengan sengaja karena, bahkan dengan inlinekata kunci, fungsi template umumnya jauh lebih agresif dioptimalkan oleh gcc daripada fungsi vanilla C (ini ada hubungannya dengan gcc yang perlu berurusan dengan pointer fungsi untuk fungsi vanilla C tetapi tidak dengan fungsi template).

1. Sementara menentukan waktu berbagai fungsi penyortiran, saya perhatikan bahwa konteks (yaitu kode di sekitarnya) tempat pemanggilan fungsi penyortiran memiliki dampak signifikan pada kinerja, yang kemungkinan disebabkan oleh fungsi yang diuraikan dan kemudian dioptimalkan. Misalnya, jika program itu cukup sederhana maka biasanya tidak ada banyak perbedaan dalam kinerja antara melewati fungsi penyortiran pointer dibandingkan melewati iterator; jika tidak menggunakan iterator biasanya menghasilkan kinerja yang jauh lebih baik dan tidak pernah (setidaknya dalam pengalaman saya sejauh ini) kinerja yang lebih buruk. Saya menduga ini mungkin karena g ++ dapat secara global mengoptimalkan kode yang cukup sederhana.

Coba urutkan daftar yang diurutkan. :) Gunakan dua array. Tercepat untuk array kecil dan besar.
Jika Anda menyimpulkan, Anda hanya memeriksa di mana memasukkan. Nilai lebih besar lainnya yang tidak perlu Anda bandingkan (cmp = ab> 0).
Untuk 4 angka, Anda dapat menggunakan sistem 4-5 cmp (~ 4.6) atau 3-6 cmp (~ 4.9). Sortir gelembung menggunakan 6 cmp (6). Banyak cmp untuk kode besar angka lambat.
Kode ini menggunakan 5 cmp (bukan MSL sort):
if (cmp(arr[n][i+0],arr[n][i+1])>0) {swap(n,i+0,i+1);} if (cmp(arr[n][i+2],arr[n][i+3])>0) {swap(n,i+2,i+3);} if (cmp(arr[n][i+0],arr[n][i+2])>0) {swap(n,i+0,i+2);} if (cmp(arr[n][i+1],arr[n][i+3])>0) {swap(n,i+1,i+3);} if (cmp(arr[n][i+1],arr[n][i+2])>0) {swap(n,i+1,i+2);}

MSL prinsipal 9 8 7 6 5 4 3 2 1 0 89 67 45 23 01 ... concat two sorted lists, list length = 1 6789 2345 01 ... concat two sorted lists, list length = 2 23456789 01 ... concat two sorted lists, list length = 4 0123456789 ... concat two sorted lists, list length = 8

kode js

function sortListMerge_2a(cmp)	
{
var step, stepmax, tmp, a,b,c, i,j,k, m,n, cycles;
var start = 0;
var end   = arr_count;
//var str = '';
cycles = 0;
if (end>3)
	{
	stepmax = ((end - start + 1) >> 1) << 1;
	m = 1;
	n = 2;
	for (step=1;step<stepmax;step<<=1)	//bounds 1-1, 2-2, 4-4, 8-8...
		{
		a = start;
		while (a<end)
			{
			b = a + step;
			c = a + step + step;
			b = b<end ? b : end;
			c = c<end ? c : end;
			i = a;
			j = b;
			k = i;
			while (i<b && j<c)
				{
				if (cmp(arr[m][i],arr[m][j])>0)
					{arr[n][k] = arr[m][j]; j++; k++;}
				else	{arr[n][k] = arr[m][i]; i++; k++;}
				}
			while (i<b)
				{arr[n][k] = arr[m][i]; i++; k++;
}
			while (j<c)
				{arr[n][k] = arr[m][j]; j++; k++;
}
			a = c;
			}
		tmp = m; m = n; n = tmp;
		}
	return m;
	}
else
	{
	// sort 3 items
	sort10(cmp);
	return m;
	}
}

Sortir 4 item dengan cmp penggunaan == 0. Jumlah cmp adalah ~ 4.34 (FF asli memiliki ~ 4.52), tetapi membutuhkan waktu 3x dari daftar penggabungan. Tapi operasi cmp lebih baik, jika Anda memiliki angka besar atau teks besar. Edit: bug yang diperbaiki

Tes online http://mlich.zam.slu.cz/js-sort/x-sort-x2.htm

function sort4DG(cmp,start,end,n) // sort 4
{
var n     = typeof(n)    !=='undefined' ? n   : 1;
var cmp   = typeof(cmp)  !=='undefined' ? cmp   : sortCompare2;
var start = typeof(start)!=='undefined' ? start : 0;
var end   = typeof(end)  !=='undefined' ? end   : arr[n].length;
var count = end - start;
var pos = -1;
var i = start;
var cc = [];
// stabilni?
cc[01] = cmp(arr[n][i+0],arr[n][i+1]);
cc[23] = cmp(arr[n][i+2],arr[n][i+3]);
if (cc[01]>0) {swap(n,i+0,i+1);}
if (cc[23]>0) {swap(n,i+2,i+3);}
cc[12] = cmp(arr[n][i+1],arr[n][i+2]);
if (!(cc[12]>0)) {return n;}
cc[02] = cc[01]==0 ? cc[12] : cmp(arr[n][i+0],arr[n][i+2]);
if (cc[02]>0)
    {
    swap(n,i+1,i+2); swap(n,i+0,i+1); // bubble last to top
    cc[13] = cc[23]==0 ? cc[12] : cmp(arr[n][i+1],arr[n][i+3]);
    if (cc[13]>0)
        {
        swap(n,i+2,i+3); swap(n,i+1,i+2); // bubble
        return n;
        }
    else    {
    cc[23] = cc[23]==0 ? cc[12] : (cc[01]==0 ? cc[30] : cmp(arr[n][i+2],arr[n][i+3]));  // new cc23 | c03 //repaired
        if (cc[23]>0)
            {
            swap(n,i+2,i+3);
            return n;
            }
        return n;
        }
    }
else    {
    if (cc[12]>0)
        {
        swap(n,i+1,i+2);
        cc[23] = cc[23]==0 ? cc[12] : cmp(arr[n][i+2],arr[n][i+3]); // new cc23
        if (cc[23]>0)
            {
            swap(n,i+2,i+3);
            return n;
            }
        return n;
        }
    else    {
        return n;
        }
    }
return n;
}

Mungkin aku am terlambat ke pesta, tapi setidaknya kontribusi saya adalah baru pendekatan.

• Kode harus benar - benar diuraikan
• bahkan jika digarisbawahi, ada terlalu banyak cabang
• bagian analisis pada dasarnya adalah O (N (N-1)) yang tampaknya OK untuk N = 6
• kode dapat lebih efektif jika biayaswap akan lebih tinggi (dari biaya compare)
• Saya percaya pada fungsi statis yang diuraikan.
• Metode ini terkait dengan sort-rank
  • alih-alih peringkat, peringkat relatif (offset) digunakan.
  • jumlah peringkat adalah nol untuk setiap siklus dalam kelompok permutasi apa pun.
  • alih-alih menggunakan SWAP()dua elemen, siklus dikejar, hanya membutuhkan satu temp, dan satu (register-> register) swap (baru <- lama).

Pembaruan: sedikit mengubah kode, beberapa orang menggunakan kompiler C ++ untuk mengkompilasi kode C ...

#include <stdio.h>

#if WANT_CHAR
typedef signed char Dif;
#else
typedef signed int Dif;
#endif

static int walksort (int *arr, int cnt);
static void countdifs (int *arr, Dif *dif, int cnt);
static void calcranks(int *arr, Dif *dif);

int wsort6(int *arr);

void do_print_a(char *msg, int *arr, unsigned cnt)
{
fprintf(stderr,"%s:", msg);
for (; cnt--; arr++) {
        fprintf(stderr, " %3d", *arr);
        }
fprintf(stderr,"\n");
}

void do_print_d(char *msg, Dif *arr, unsigned cnt)
{
fprintf(stderr,"%s:", msg);
for (; cnt--; arr++) {
        fprintf(stderr, " %3d", (int) *arr);
        }
fprintf(stderr,"\n");
}

static void inline countdifs (int *arr, Dif *dif, int cnt)
{
int top, bot;

for (top = 0; top < cnt; top++ ) {
        for (bot = 0; bot < top; bot++ ) {
                if (arr[top] < arr[bot]) { dif[top]--; dif[bot]++; }
                }
        }
return ;
}
        /* Copied from RexKerr ... */
static void inline calcranks(int *arr, Dif *dif){

dif[0] =     (arr[0]>arr[1])+(arr[0]>arr[2])+(arr[0]>arr[3])+(arr[0]>arr[4])+(arr[0]>arr[5]);
dif[1] = -1+ (arr[1]>=arr[0])+(arr[1]>arr[2])+(arr[1]>arr[3])+(arr[1]>arr[4])+(arr[1]>arr[5]);
dif[2] = -2+ (arr[2]>=arr[0])+(arr[2]>=arr[1])+(arr[2]>arr[3])+(arr[2]>arr[4])+(arr[2]>arr[5]);
dif[3] = -3+ (arr[3]>=arr[0])+(arr[3]>=arr[1])+(arr[3]>=arr[2])+(arr[3]>arr[4])+(arr[3]>arr[5]);
dif[4] = -4+ (arr[4]>=arr[0])+(arr[4]>=arr[1])+(arr[4]>=arr[2])+(arr[4]>=arr[3])+(arr[4]>arr[5]);
dif[5] = -(dif[0]+dif[1]+dif[2]+dif[3]+dif[4]);
}

static int walksort (int *arr, int cnt)
{
int idx, src,dst, nswap;

Dif difs[cnt];

#if WANT_REXK
calcranks(arr, difs);
#else
for (idx=0; idx < cnt; idx++) difs[idx] =0;
countdifs(arr, difs, cnt);
#endif
calcranks(arr, difs);

#define DUMP_IT 0
#if DUMP_IT
do_print_d("ISteps ", difs, cnt);
#endif

nswap = 0;
for (idx=0; idx < cnt; idx++) {
        int newval;
        int step,cyc;
        if ( !difs[idx] ) continue;
        newval = arr[idx];
        cyc = 0;
        src = idx;
        do      {
                int oldval;
                step = difs[src];
                difs[src] =0;
                dst = src + step;
                cyc += step ;
                if(dst == idx+1)idx=dst;
                oldval = arr[dst];
#if (DUMP_IT&1)
                fprintf(stderr, "[Nswap=%d] Cyc=%d Step=%2d Idx=%d  Old=%2d New=%2d #### Src=%d Dst=%d[%2d]->%2d <-- %d\n##\n"
                        , nswap, cyc, step, idx, oldval, newval
                        , src, dst, difs[dst], arr[dst]
                        , newval  );
                do_print_a("Array ", arr, cnt);
                do_print_d("Steps ", difs, cnt);
#endif

                arr[dst] = newval;
                newval = oldval;
                nswap++;
                src = dst;
                } while( cyc);
        }

return nswap;
}
/*************/
int wsort6(int *arr)
{
return walksort(arr, 6);
}

//Bruteforce compute unrolled count dumbsort(min to 0-index)
void bcudc_sort6(int* a)
{
    int t[6] = {0};
    int r1,r2;

    r1=0;
    r1 += (a[0] > a[1]);
    r1 += (a[0] > a[2]);
    r1 += (a[0] > a[3]);
    r1 += (a[0] > a[4]);
    r1 += (a[0] > a[5]);
    while(t[r1]){r1++;}
    t[r1] = a[0];

    r2=0;
    r2 += (a[1] > a[0]);
    r2 += (a[1] > a[2]);
    r2 += (a[1] > a[3]);
    r2 += (a[1] > a[4]);
    r2 += (a[1] > a[5]);
    while(t[r2]){r2++;} 
    t[r2] = a[1];

    r1=0;
    r1 += (a[2] > a[0]);
    r1 += (a[2] > a[1]);
    r1 += (a[2] > a[3]);
    r1 += (a[2] > a[4]);
    r1 += (a[2] > a[5]);
    while(t[r1]){r1++;}
    t[r1] = a[2];

    r2=0;
    r2 += (a[3] > a[0]);
    r2 += (a[3] > a[1]);
    r2 += (a[3] > a[2]);
    r2 += (a[3] > a[4]);
    r2 += (a[3] > a[5]);
    while(t[r2]){r2++;} 
    t[r2] = a[3];

    r1=0;
    r1 += (a[4] > a[0]);
    r1 += (a[4] > a[1]);
    r1 += (a[4] > a[2]);
    r1 += (a[4] > a[3]);
    r1 += (a[4] > a[5]);
    while(t[r1]){r1++;}
    t[r1] = a[4];

    r2=0;
    r2 += (a[5] > a[0]);
    r2 += (a[5] > a[1]);
    r2 += (a[5] > a[2]);
    r2 += (a[5] > a[3]);
    r2 += (a[5] > a[4]);
    while(t[r2]){r2++;} 
    t[r2] = a[5];

    a[0]=t[0];
    a[1]=t[1];
    a[2]=t[2];
    a[3]=t[3];
    a[4]=t[4];
    a[5]=t[5];
}

static __inline__ void sort6(int* a)
{
    #define wire(x,y); t = a[x] ^ a[y] ^ ( (a[x] ^ a[y]) & -(a[x] < a[y]) ); a[x] = a[x] ^ t; a[y] = a[y] ^ t;
    register int t;

    wire( 0, 1); wire( 2, 3); wire( 4, 5);
    wire( 3, 5); wire( 0, 2); wire( 1, 4);
    wire( 4, 5); wire( 2, 3); wire( 0, 1); 
    wire( 3, 4); wire( 1, 2); 
    wire( 2, 3);

    #undef wire
}

Nah, jika hanya 6 elemen dan Anda dapat memanfaatkan paralelisme, ingin meminimalkan percabangan bersyarat, dll. Mengapa Anda tidak menghasilkan semua kombinasi dan menguji pesanan? Saya berani mengatakan bahwa dalam beberapa arsitektur, itu bisa sangat cepat (selama Anda memiliki memori yang dialokasikan sebelumnya)

Berikut adalah tiga metode penyortiran khas yang mewakili tiga kelas yang berbeda dari Algoritma Penyortiran:

Insertion Sort: Θ(n^2)

Heap Sort: Θ(n log n)

Count Sort: Θ(3n)

Tapi lihat diskusi Stefan Nelsson tentang algoritma penyortiran tercepat? di mana ia membahas solusi yang turun ke O(n log log n).. periksa implementasinya di C

Algoritma Penyortiran Semi-Linier ini disajikan oleh sebuah makalah pada tahun 1995:

A. Andersson, T. Hagerup, S. Nilsson, dan R. Raman. Mengurutkan dalam waktu linier? Dalam Prosiding Simposium ACM Tahunan ke-27 tentang Teori Komputasi, halaman 427-436, 1995.