跳到主要內容

Priority Queues,again!!

在讀書時,只要有修過資料結構課程,一定都有接觸過Priority Queue的概念,priority queue的應用範圍很廣泛,也知道高效的Priority Queue一般都會以Heap來實作,但隨著遠離學生時代,每天在繁雜的軟體架構中求生存,不斷地把時間花在debug、了解現存介面的使用,有時不免讓人覺得有些疲憊(當然啦,有時開發某些模組還是頗有挑戰性,但我一般80%的時間的確都是勞力為主:P)。所以為了讓自己保持清醒,今晚就來複習一下Priority Queues的概念吧~

Priority Queues通常至少支援兩個操作:insert和delete_min。如果需要動態改變元素的priority,那麼還會再支援increase_priority, decrease_priority。甚至,有時會需要頻繁的合併多個Priority Queues,所以merge_priority_queue有時也是必要的,而高效的merge需要更複雜的heap,像是binomial heap或是Fibonacci heap

讓我們先考慮基本操作:insert以及delete_min就好。如果只要支援這兩個操作,我們可以簡單地利用binary heap來完成。由於binary heap的結構通常非常精簡,可以array來實作,所以從任一元素找尋其parent與children都非常快速。以下是我用C語言的試作代碼。

注意:雖然我有針對使用的型別別作了一般化,但對於內建型別(如整數)可能會帶來些許性能損失。當然啦,如果用C++,就可以用 template specialization 把這個問題去除。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#include <stdio.h>
#include <stdlib.h>
 
/* ADT for priority queue */
struct priority_q;
 
struct priority_q_ele_ops {
    int (*is_larger)(void *lhs, void *rhs);
    void (*assign)(void *lhs, void *rhs);
};
 
struct priority_q *create_priority_q(int max_nr, int ele_size, void *min_ele, struct priority_q_ele_ops *pqe_ops);
void destroy_priority_q(struct priority_q *q);
void priority_q_insert(struct priority_q *q, void *e);
void priority_q_del_min(struct priority_q *q, void *min_ele);
 
/* we use heap to imp priority queue */
 
struct priority_q {
    int capacity;
    int cur_nr;
    int ele_size;
    void *elements;
    struct priority_q_ele_ops *pqe_ops;
} ;
 
struct priority_q *create_priority_q(int max_nr, int ele_size, void *min_ele, struct priority_q_ele_ops *pqe_ops)
{
    struct priority_q *q = NULL;
 
    q = malloc(sizeof(struct priority_q));
    if (!q) {
        fprintf(stderr, "in %s: malloc heap failed.\n", __func__);
        goto malloc_heap_fail;
    }   
 
    q->capacity = max_nr;
    q->cur_nr = 0;
 
    q->ele_size = ele_size;
    q->elements = malloc(ele_size*(max_nr+1));
    if (!q->elements) {
        fprintf(stderr, "in %s: malloc elements failed.\n", __func__);
        goto malloc_ele_fail;
    }
 
    q->pqe_ops = pqe_ops;
 
    /* set elements[0] as min_ele's value for later efficient testing */
    q->pqe_ops->assign(q->elements, min_ele);
 
    return q;
 
malloc_ele_fail:
    free(q);
malloc_heap_fail:
    return NULL;
}
 
void destroy_priority_q(struct priority_q *q)
{
    free(q->elements);
    free(q);
}
 
static inline int pq_is_larger(struct priority_q *q, void *lhs, void *rhs)
{
    return q->pqe_ops->is_larger(lhs, rhs);
}
 
static inline void *pq_ith_ele(struct priority_q *q, int i)
{
    return (q->elements + (q->ele_size*i));
}
 
static inline void pq_assign(struct priority_q *q, void *lhs, void *rhs)
{
    q->pqe_ops->assign(lhs, rhs);
}
 
void priority_q_insert(struct priority_q *q, void *e)
{
    int i = 0;
 
    q->cur_nr += 1;
    for (i = q->cur_nr ; pq_is_larger(q, pq_ith_ele(q, i/2), e) ; i /= 2) {
        pq_assign(q, pq_ith_ele(q, i), pq_ith_ele(q, i/2));
    }
 
    pq_assign(q, pq_ith_ele(q, i), e);
}
 
void priority_q_del_min(struct priority_q *q, void *min_ele)
{
    int i = 0;
    int child = 0;
    void *last_ele = NULL;
 
    pq_assign(q, min_ele, pq_ith_ele(q, 1));
    last_ele = pq_ith_ele(q, q->cur_nr--);
 
    for (i = 1 ; (i*2) <= q->cur_nr; i = child) {
        child = i*2;
        if (child != q->cur_nr && pq_is_larger(q, pq_ith_ele(q, child), pq_ith_ele(q, child+1))) {
            child++;
        }
 
        if (pq_is_larger(q, last_ele, pq_ith_ele(q, child))) {
            pq_assign(q, pq_ith_ele(q, i), pq_ith_ele(q, child));
        } else {
 
            break;
        }
    }
 
    pq_assign(q, pq_ith_ele(q, i), last_ele);
}
 
/* test code, use int as element */
static int int_is_larger(void *lhs, void *rhs)
{
    int *L = lhs;
    int *R = rhs;
 
    return (*L) > (*R);
}
 
static void int_assign(void *lhs, void *rhs)
{
    int *L = lhs;
    int *R = rhs;
 
    *L = *R;
}
 
struct priority_q_ele_ops int_ops = {
    .is_larger = int_is_larger,
    .assign = int_assign
};
 
int main(void)
{
    int min = -99999;
    struct priority_q *q = NULL;
    int i = 0;
    int input[9] = {-9, -1, 10, 3, -7, 100, 75, 9, -3};
 
    q = create_priority_q(100, sizeof(int), &min, &int_ops);
    if (!q) {
        fprintf(stderr, "create q fail.\n");
    }
 
    for (i = 0; i < 9 ; ++i) {
        priority_q_insert(q, &input[i]);
    }
 
    for (i = 0; i < 9 ; ++i) {
        int val = 0;
        priority_q_del_min(q, &val);
        printf("%d ", val);
    }
 
    printf("\n");
 
    return 0;
}

留言

這個網誌中的熱門文章

誰在呼叫我?不同的backtrace實作說明好文章

今天下班前一個同事問到:如何在Linux kernel的function中主動印出backtrace以方便除錯? 寫過kernel module的人都知道,基本上就是用dump_stack()之類的function就可以作到了。但是dump_stack()的功能是如何作到的呢?概念上其實並不難,慣用手法就是先觀察stack在function call時的變化(一般OS或計組教科書都有很好的說明,如果不想翻書,可以參考 這篇 ),然後將對應的return address一層一層找出來後,再將對應的function名稱印出即可(透過執行檔中的section去讀取函式名稱即可,所以要將KALLSYM選項打開)。在userspace的實作可參考Jserv介紹過的 whocallme 或對岸好手實作過的 backtrace() ,都是針對x86架構的很好說明文章。 不過從前面兩篇文章可以知道,只要知道編譯器的calling convention,就可以實作出backtrace,所以是否GCC有提供現成的機制呢?Yes, that is what __builtin_return_address() for!! 可以參考這篇 文章 。該篇文章還提到了其他可以拿來實作功能更齊全的backtrace的 程式庫 ,在了解了運作原理後,用那些東西還蠻方便的。 OK,那Linux kernel是怎麼做的呢?就是用頭兩篇文章的方式啦~ 每個不同的CPU架構各自手工實作一份dump_stack()。 為啥不用GCC的機制?畢竟...嗯,我猜想,除了backtrace以外,開發者還會想看其他register的值,還有一些有的沒的,所以光是GCC提供的介面是很難印出全部所要的資訊,與其用半套GCC的機制,不如全都自己來~ arm的實作 大致上長這樣,可以看到基本上就只是透過迭代fp, lr, pc來完成: 352 void unwind_backtrace (struct pt_regs * regs , struct task_struct *tsk) 353 { 354 struct stackframe frame ; 355 register unsigned long current_sp asm ( "

淺讀Linux root file system初始化流程

在Unix的世界中,file system佔據一個極重要的抽象化地位。其中,/ 所代表的rootfs更是所有後續新增file system所必須依賴前提條件。以Linux為例,黑客 Jserv 就曾經詳細說明過 initramfs的背後設計考量 。本篇文章不再重複背景知識,主要將追蹤rootfs初始化的流程作點整理,免得自己日後忘記。 :-) file system與特定CPU架構無關,所以我觀察的起點從init/main.c的start_kernel()開始,這是Linux作完基本CPU初始化後首先跳進的C function(我閱讀的版本為 3.12 )。跟root file system有關的流程羅列如下: start_kernel()         -> vfs_caches_init_early()         -> vfs_caches_init()                 -> mnt_init()                         -> init_rootfs()                         -> init_mount_tree()         -> rest_init()                 -> kernel_thread(kernel_init,...) 其中比較重要的是mnt_int()中的init_rootfs()與init_mout_tree()。init_rootfs()實作如下: int __init init_rootfs(void) {         int err = register_filesystem(&rootfs_fs_type);         if (err)                 return err;         if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&                 (!root_fs_names || strstr(root_fs_names, "tmpfs"))) {          

kernel panic之後怎麼辦?

今天同事在處理一個陌生的模組時遇到kernel panic,Linux印出了backtrace,同事大致上可以知道是在哪個function中,但該function的長度頗長,短時間無法定位在哪個位置,在這種情況下,要如何收斂除錯範圍呢?更糟的是,由於加入printk會改變模組行為,所以printk基本上無法拿來檢查參數的值是否正常。 一般這樣的問題會backtrace的資訊來著手。從這個資訊我們可以知道在function中的多少offset發生錯誤,以x86為例(從 LDD3 借來的例子): Unable to handle kernel NULL pointer dereference at virtual address 00000000 printing eip: d083a064 Oops: 0002 [#1] SMP CPU:    0 EIP:    0060:[<d083a064>]    Not tainted EFLAGS: 00010246   (2.6.6) EIP is at faulty_write+0x4/0x10 [faulty] eax: 00000000   ebx: 00000000   ecx: 00000000   edx: 00000000 esi: cf8b2460   edi: cf8b2480   ebp: 00000005   esp: c31c5f74 ds: 007b   es: 007b   ss: 0068 Process bash (pid: 2086, threadinfo=c31c4000 task=cfa0a6c0) Stack: c0150558 cf8b2460 080e9408 00000005 cf8b2480 00000000 cf8b2460 cf8b2460        fffffff7 080e9408 c31c4000 c0150682 cf8b2460 080e9408 00000005 cf8b2480        00000000 00000001 00000005 c0103f8f 00000001 080e9408 00000005 00000005 Call Trace:  [<c0150558>] vfs