外部排序

来源:岁月联盟 编辑:exp 时间:2012-10-17

一 外部排序的基本思路
假设有一个72KB的文件,其中存储了18K个整数,磁盘中物理块的大小为4KB,将文件分成18组,每组刚好4KB。
首先通过18次内部排序,把18组数据排好序,得到初始的18个归并段R1~R18,每个归并段有1024个整数。
然后对这18个归并段使用4路平衡归并排序:
第1次归并:产生5个归并段
R11   R12    R13    R14    R15
其中
R11是由{R1,R2,R3,R4}中的数据合并而来
R12是由{R5,R6,R7,R8}中的数据合并而来
R13是由{R9,R10,R11,R12}中的数据合并而来
R14是由{R13,R14,R15,R16}中的数据合并而来
R15是由{R17,R18}中的数据合并而来
把这5个归并段的数据写入5个文件:
foo_1.dat    foo_2.dat    foo_3.dat     foo_4.dat     foo_5.dat
 
第2次归并:从第1次归并产生的5个文件中读取数据,合并,产生2个归并段
R21  R22
其中R21是由{R11,R12,R13,R14}中的数据合并而来
其中R22是由{R15}中的数据合并而来
把这2个归并段写入2个文件
bar_1.dat   bar_2.dat
 
第3次归并:从第2次归并产生的2个文件中读取数据,合并,产生1个归并段
R31
R31是由{R21,R22}中的数据合并而来
把这个文件写入1个文件
foo_1.dat
此即为最终排序好的文件。
 
二 使用败者树加快合并排序
外部排序最耗时间的操作时磁盘读写,对于有m个初始归并段,k路平衡的归并排序,磁盘读写次数为
|logkm|,可见增大k的值可以减少磁盘读写的次数,但增大k的值也会带来负面效应,即进行k路合并
的时候会增加算法复杂度,来看一个例子。
把n个整数分成k组,每组整数都已排序好,现在要把k组数据合并成1组排好序的整数,求算法复杂度
u1: xxxxxxxx
u2: xxxxxxxx
u3: xxxxxxxx
.......
uk: xxxxxxxx
算法的步骤是:每次从k个组中的首元素中选一个最小的数,加入到新组,这样每次都要比较k-1次,故
算法复杂度为O((n-1)*(k-1)),而如果使用败者树,可以在O(logk)的复杂度下得到最小的数,算法复杂
度将为O((n-1)*logk), 对于外部排序这种数据量超大的排序来说,这是一个不小的提高。
 
关于败者树的创建和调整,可以参考清华大学《数据结构-C语言版》
 
三 产生二进制测试数据
打开Linux终端,输入命令
dd if=/dev/urandom of=random.dat bs=1M count=512
 这样在当前目录下产生一个512M大的二进制文件,文件内的数据是随机的,读取文件,每4个字节
看成1个整数,相当于得到128M个随机整数。
 
四 程序实现
[cpp] 
#include <assert.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
 
#include <sys/time.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
 
#define MAX_INT ~(1<<31) 
#define MIN_INT 1<<31 
 
//#define DEBUG 
 
#ifdef DEBUG 
#define debug(...) debug( __VA_ARGS__)  
#else 
#define debug(...) 
#endif 
 
#define MAX_WAYS 100 
 
typedef struct run_t { 
    int *buf;       /* 输入缓冲区 */ 
    int length;     /* 缓冲区当前有多少个数 */ 
    int offset;     /* 缓冲区读到了文件的哪个位置 */ 
    int idx;        /* 缓冲区的指针 */ 
} run_t; 
 
static unsigned int K;              /* K路合并 */ 
static unsigned int BUF_PAGES;      /* 缓冲区有多少个page */ 
static unsigned int PAGE_SIZE;      /* page的大小 */ 
static unsigned int BUF_SIZE;       /* 缓冲区的大小, BUF_SIZE = BUF_PAGES*PAGE_SIZE */ 
 
static int *buffer;                 /* 输出缓冲区 */ 
 
static char input_prefix[] = "foo_"; 
static char output_prefix[] = "bar_"; 
 
static int ls[MAX_WAYS];            /* loser tree */ 
 
void swap(int *p, int *q); 
int partition(int *a, int s, int t); 
void quick_sort(int *a, int s, int t); 
void adjust(run_t ** runs, int n, int s); 
void create_loser_tree(run_t **runs, int n); 
long get_time_usecs(); 
void k_merge(run_t** runs, char* input_prefix, int num_runs, int base, int n_merge); 
void usage(); 
 
 
int main(int argc, char **argv) 

    char                filename[100]; 
    unsigned int    data_size; 
    unsigned int    num_runs;               /* 这轮迭代时有多少个归并段 */ 
    unsigned int    num_merges;             /* 这轮迭代后产生多少个归并段 num_merges = num_runs/K */ 
    unsigned int    run_length;             /* 归并段的长度,指数级增长 */ 
    unsigned int    num_runs_in_merge;      /* 一般每个merge由K个runs合并而来,但最后一个merge可能少于K个runs */ 
    int                 fd, rv, i, j, bytes; 
    struct stat         sbuf; 
 
    if (argc != 3) { 
        usage(); 
        return 0; 
    } 
    long start_usecs = get_time_usecs(); 
 
    strcpy(filename, argv[1]); 
    fd = open(filename, O_RDONLY); 
    if (fd < 0) { 
        printf("can't open file %s/n", filename); 
        exit(0); 
    } 
    rv = fstat(fd, &sbuf); 
    data_size = sbuf.st_size; 
 
    K = atoi(argv[2]); 
    PAGE_SIZE = 4096;                           /* page = 4KB */ 
    BUF_PAGES = 32; 
    BUF_SIZE = PAGE_SIZE*BUF_PAGES; 
    num_runs = data_size / PAGE_SIZE;           /* 初始时的归并段数量,每个归并段有4096 byte, 即1024个整数 */ 
    buffer = (int *)malloc(BUF_SIZE); 
 
    run_length = 1; 
    run_t **runs = (run_t **)malloc(sizeof(run_t *)*(K+1)); 
    for (i = 0; i < K; i++) { 
        runs[i] = (run_t *)malloc(sizeof(run_t)); 
        runs[i]->buf = (int *)calloc(1, BUF_SIZE+4); 
    } 
    while (num_runs > 1) { 
        num_merges = num_runs / K; 
        int left_runs = num_runs % K; 
        if(left_runs > 0) num_merges++; 
        for (i = 0; i < num_merges; i++) { 
            num_runs_in_merge = K; 
            if ((i+1) == num_merges && left_runs > 0) { 
                num_runs_in_merge = left_runs; 
            } 
            int base = 0; 
            printf("Merge %d of %d,%d ways/n", i, num_merges, num_runs_in_merge); 
            for (j = 0; j < num_runs_in_merge; j++) { 
                if (run_length == 1) { 
                    base = 1; 
                    bytes = read(fd, runs[j]->buf, PAGE_SIZE); 
                    runs[j]->length = bytes/sizeof(int); 
                    quick_sort(runs[j]->buf, 0, runs[j]->length-1); 
                } else { 
                    snprintf(filename, 20, "%s%d.dat", input_prefix, i*K+j); 
                    int infd = open(filename, O_RDONLY); 
                    bytes = read(infd, runs[j]->buf, BUF_SIZE); 
                    runs[j]->length = bytes/sizeof(int); 
                    close(infd);     
                } 
                runs[j]->idx = 0; 
                runs[j]->offset = bytes; 
            } 
            k_merge(runs, input_prefix, num_runs_in_merge, base, i); 
        } 
 
        strcpy(filename, output_prefix); 
        strcpy(output_prefix, input_prefix); 
        strcpy(input_prefix, filename); 
 
        run_length *= K; 
        num_runs = num_merges; 
    } 
 
    for (i = 0; i < K; i++) { 
        free(runs[i]->buf); 
        free(runs[i]); 
    } 
    free(runs); 
    free(buffer); 
    close(fd); 
 
    long end_usecs = get_time_usecs(); 
    double secs = (double)(end_usecs - start_usecs) / (double)1000000; 
    printf("Sorting took %.02f seconds./n", secs); 
    printf("sorting result saved in %s%d.dat./n", input_prefix, 0); 
 
    return 0; 

 
void k_merge(run_t** runs, char* input_prefix, int num_runs, int base, int n_merge) 

    int bp, bytes, output_fd; 
    int live_runs = num_runs; 
    run_t *mr; 
    char filename[20]; 
 
    bp = 0; 
    create_loser_tree(runs, num_runs); 
 
    snprintf(filename, 100, "%s%d.dat", output_prefix, n_merge); 
    output_fd = open(filename, O_CREAT|O_WRONLY|O_TRUNC,  
            S_IRWXU|S_IRWXG); 
    if (output_fd < 0) { 
        printf("create file %s fail/n", filename); 
        exit(0); 
    } 
 
    while (live_runs > 0) { 
        mr = runs[ls[0]]; 
        buffer[bp++] = mr->buf[mr->idx++]; 
        // 输出缓冲区已满 
        if (bp*4 == BUF_SIZE) { 
            bytes = write(output_fd, buffer, BUF_SIZE); 
            bp = 0; 
        } 
        // mr的输入缓冲区用完 
        if (mr->idx == mr->length) { 
            snprintf(filename, 20, "%s%d.dat", input_prefix, ls[0]+n_merge*K); 
            if (base) { 
                mr->buf[mr->idx] = MAX_INT; 
                live_runs--; 
            } else { 
                int fd = open(filename, O_RDONLY); 
                lseek(fd, mr->offset, SEEK_SET); 
                bytes = read(fd, mr->buf, BUF_SIZE); 
                close(fd); 
                if (bytes == 0) { 
                    mr->buf[mr->idx] = MAX_INT; 
                    live_runs--; 
                } 
                else { 
                    mr->length = bytes/sizeof(int); 
                    mr->offset += bytes; 
                    mr->idx = 0; 
                } 
            } 
        } 
        adjust(runs, num_runs, ls[0]); 
    } 
    bytes = write(output_fd, buffer, bp*4); 
    if (bytes != bp*4) { 
        printf("!!!!!! Write Error !!!!!!!!!/n"); 
        exit(0); 
    } 
    close(output_fd); 

 
long get_time_usecs() 

    struct timeval time; 
    struct timezone tz; 
    memset(&tz, '/0', sizeof(struct timezone)); 
    gettimeofday(&time, &tz); 
    long usecs = time.tv_sec*1000000 + time.tv_usec; 
 
    return usecs; 

 
void swap(int *p, int *q) 

    int     tmp; 
 
    tmp = *p; 
    *p = *q; 
    *q = tmp; 

 
int partition(int *a, int s, int t) 

    int     i, j;   /* i用来遍历a[s]...a[t-1], j指向大于x部分的第一个元素 */ 
 
    for (i = j = s; i < t; i++) { 
        if (a[i] < a[t]) { 
            swap(a+i, a+j); 
            j++; 
        } 
    } 
    swap(a+j, a+t); 
 
    return j; 

 
void quick_sort(int *a, int s, int t) 

    int     p; 
 
    if (s < t) { 
        p = partition(a, s, t); 
        quick_sort(a, s, p-1); 
        quick_sort(a, p+1, t); 
    } 

 
void adjust(run_t ** runs, int n, int s) 

    int t, tmp; 
 
    t = (s+n)/2; 
    while (t > 0) { 
        if (s == -1) { 
            break; 
        } 
        if (ls[t] == -1 || runs[s]->buf[runs[s]->idx] > runs[ls[t]]->buf[runs[ls[t]]->idx]) { 
            tmp = s; 
            s = ls[t]; 
            ls[t] = tmp; 
        } 
        t >>= 1; 
    } 
    ls[0] = s; 

 
void create_loser_tree(run_t **runs, int n) 

    int     i; 
 
    for (i = 0; i < n; i++) { 
        ls[i] = -1; 
    } 
    for (i = n-1; i >= 0; i--) { 
        adjust(runs, n, i); 
    } 

 
void usage() 

    printf("sort <filename> <K-ways>/n"); 
    printf("/tfilename: filename of file to be sorted/n"); 
    printf("/tK-ways: how many ways to merge/n"); 
    exit(1); 

五 编译运行
gcc sort.c -o sort -g
./sort random.dat 64
以64路平衡归并对random.dat内的数据进行外部排序。在I5处理器,4G内存的硬件环境下,实验结果如下
文件大小    耗时
128M        14.72 秒
256M        30.89 秒
512M        71.65 秒
1G             169.18秒
 
六 读取二进制文件,查看排序结
[cpp]
#include <assert.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
 
#include <sys/time.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
 
int main(int argc, char **argv) 

    char *filename = argv[1]; 
    int *buffer = (int *)malloc(1<<20); 
    struct stat     sbuf; 
    int rv, data_size, i, bytes, fd; 
 
    fd = open(filename, O_RDONLY); 
    if (fd < 0) { 
        printf("%s not found!/n", filename); 
        exit(0); 
    } 
    rv = fstat(fd, &sbuf); 
    data_size = sbuf.st_size; 
 
    bytes = read(fd, buffer, data_size); 
    for (i = 0; i < bytes/4; i++) { 
        printf("%d ", buffer[i]); 
        if ((i+1) % 10 == 0) { 
            printf("/n"); 
        } 
    } 
    printf("/n"); 
    close(fd); 
    free(buffer); 
    return 0; 

图片内容