MSD_radix_sort

一、这次是在上一次尝试基础上进行的，预期是达到上次性能的9倍。

MSD的基本手法就是不断切片。
每一步都是把整体数据切割成256片，如上图所示，实际情况切片未必均匀，有的slice内可能一个元素也没有。

接下来对于每个切片怎么办呢？
答案是继续切，对于特殊数据来讲，切片过程可以很快结束，这样就可以实现比LSD更快的速度。

这里面最困难的地方就是如何存储每个slice的头和尾。
如果采用下述方式，应该是行不通的。
这个方式需要做数组元素插入，还要跟踪中间数据，因此没具体考虑。

我真正采用的是下表：

表中第一项表示第一个元素开启一个类别，紧跟的0表示此元素和上面的1是同一类。
至于2表明在切片过程中是一个孤立的元素，后续就没必要再切片了。
这个方式可以大大简化编码。

 

二、伪代码。

for each slice

    if slice-tag == 2 continue;

    if slice-tag == 1

        slice it;

        update bookkeeping

int main(){

    HANDLE heap = NULL;

    Bucket bucket[BUCKETSLOTCOUNT];

    PageList * pageListPool;

    int plpAvailable = 0;

    int * pages = NULL;

    int * pagesAvailable = NULL;

    int * objIdx;

    unsigned short * s;

    __int8 * classifier = NULL;



    time_t timeBegin;

    time_t timeEnd;



    heap = HeapCreate(HEAP_NO_SERIALIZE|HEAP_GENERATE_EXCEPTIONS, 1024*1024, 0);

    if (heap != NULL){

        pages = (int * )HeapAlloc(heap, 0, (TFSI/PAGEGRANULAR + BUCKETSLOTCOUNT + 8) * PAGEAMOUNT);

        pageListPool = (PageList *)HeapAlloc(heap, 0, (TFSI/PAGEGRANULAR + 8) * sizeof(PageList));

        s = (unsigned short *)HeapAlloc(heap, 0, TFSI*sizeof(unsigned short));

        objIdx = (int *)HeapAlloc(heap, 0, TFSI * sizeof(int));

        classifier = (__int8 *)HeapAlloc(heap, 0, (TFSI+8)*sizeof(__int8));

    }

    MakeSure(pages != NULL && pageListPool != NULL && objIdx != NULL && classifier != NULL);



    for(int i=0; i<TFSI; i++) objIdx[i]=i;

    timeBegin = clock();

    for (int i=0; i<TFSI; i++) s[i] = rand();

    timeEnd = clock();

    printf("\n%f(s) consumed in generating numbers", (double)(timeEnd-timeBegin)/CLOCKS_PER_SEC);



    SecureZeroMemory(classifier, TFSI*sizeof(__int8));

    classifier[0] = 1;

    classifier[TFSI] = 1;

    

    timeBegin = clock();



    bool no_need_further_processing = false;

    for (int t=sizeof(short)-1; t>=0; t--){

        int bucketIdx;

        int slice_pointer = 0;

        int slice_base = 0;

        int flagCounter = 0;



        if (no_need_further_processing) break;



        //classifier: 1 new catagory

        //classifier: 2 completed catagory process

        while (slice_pointer < TFSI){

            if (classifier[slice_pointer] == 2){

                slice_base = slice_pointer;

                classifier[slice_base] = 0;

                while (classifier[slice_pointer] == 0){

                    slice_pointer++;

                    flagCounter++;

                }

                classifier[slice_base] = 2;



                if (flagCounter == TFSI) no_need_further_processing = true;

                continue;

            }

            

            if (classifier[slice_pointer] == 1){

                FillMemory(pages, (TFSI/PAGEGRANULAR + BUCKETSLOTCOUNT + 8) * PAGEAMOUNT, 0xff);

                SecureZeroMemory(pageListPool, (TFSI/PAGEGRANULAR + 8) * sizeof(PageList));

                pagesAvailable = pages;

                plpAvailable = 0;



                for(int i=0; i<256; i++){

                    bucket[i].currentPagePtr = pagesAvailable;

                    bucket[i].offset = 0;

                    bucket[i].pl.PagePtr = pagesAvailable;

                    bucket[i].pl.next = NULL;

                    pagesAvailable += PAGEGRANULAR;

                    bucket[i].currentPageListItem = &(bucket[i].pl);

                }



                slice_base = slice_pointer;

                classifier[slice_base] = 0;

                while (classifier[slice_pointer] == 0){

                    //for each slice element, push_back to pages;

                    unsigned char * cell = (unsigned char *)&s[objIdx[slice_pointer]];

                    bucketIdx =  cell[t];

                    //save(bucketIdx, objIdx[i]);

                    bucket[bucketIdx].currentPagePtr[ bucket[bucketIdx].offset ] = objIdx[slice_pointer];

                    bucket[bucketIdx].offset++;

                    if (bucket[bucketIdx].offset == PAGEGRANULAR){

                        bucket[bucketIdx].currentPageListItem->next = &pageListPool[plpAvailable];

                        plpAvailable++;

                        bucket[bucketIdx].currentPageListItem->next->PagePtr = pagesAvailable;

                        bucket[bucketIdx].currentPageListItem->next->next = NULL;

                        

                        bucket[bucketIdx].currentPagePtr = pagesAvailable;

                        bucket[bucketIdx].offset = 0;

                        pagesAvailable += PAGEGRANULAR;

                        

                        bucket[bucketIdx].currentPageListItem = bucket[bucketIdx].currentPageListItem->next;

                    }



                    slice_pointer++;

                }

                classifier[slice_base] = 1;



                //update classifier;

                //update objIdx index

                int start = slice_base;

                for (int i=0; i<256; i++){

                    PageList * p;

                    p = &(bucket[i].pl);

                    //classifier: 1 new catagory

                    //classifier: 2 complete catagory process

                    classifier[start] = 1;



                    int counters = 0;

                    while (p){

                        for (int t=0; t<PAGEGRANULAR; t++){

                            int idx = p->PagePtr[t];

                            if (idx != TERMINATOR){

                                objIdx[start] = idx;

                                start++;

                                counters++;

                            }

                            if (idx == TERMINATOR) break;

                        }

                        p = p->next;

                    }

                    if (counters == 1) classifier[start-1] = 2;

                }

                //update objIdx index

            }   //if (classifier[slice_pointer] == 1)

        }        //while (slice_pointer < TFSI) 

    }            //for (int t=sizeof(short)-1; t>=0; t--)



    timeEnd = clock();

    printf("\n%f(s) consumed in generating results", (double)(timeEnd-timeBegin)/CLOCKS_PER_SEC);

    

    //for(int i=0; i<TFSI; i++) printf("%d\n", s[objIdx[i]]);



    HeapFree(heap, 0, pages);

    HeapFree(heap, 0, pageListPool);

    HeapFree(heap, 0, s);

    HeapFree(heap, 0, objIdx);

    HeapFree(heap, 0, classifier);

    HeapDestroy(heap);



    return 0;

}

 

三、测试

1024*1024*100 个短整型。

时间  5.438s

看到这里就知道杯具了，比LSD还慢。

如果应用到二维表，会更惨不忍睹。试了下果然如此。

四、讨论

如果哪位有更好的方法，欢迎讨论。

或者，基数排序只是一个花瓶？