跳到主要內容

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;
}
標籤：

留言

張貼留言

這個網誌中的熱門文章

淺讀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_root...
張貼留言
閱讀完整內容

誰在呼叫我？不同的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 ( "...
13 則留言
閱讀完整內容

中文試譯：Writing a game in Python with Pygame. Part I

原文作者： Eli Bendersky 原文連結： http://eli.thegreenplace.net/2008/12/13/writing-a-game-in-python-with-pygame-part-i/ 簡介 遊戲是最能應用程式設計技巧的領域之一。為了寫出最簡單的遊戲，你必須跟圖像、數學、物理甚至是人工智慧打交道。寫遊戲非常酷，而且也是練習程式設計的有趣方式。 如果你是Python的粉絲（就算你不是也無妨），並且對遊戲有興趣，那麼 Pygame 就是很屌的遊戲程式設計庫，你一定要注意它。它可以在所有主要的平台執行，並提供簡單的工具去管理複雜的、充滿變動與音效的世界。 在網路上有很多Pygame的教學，但大都太過簡單了。甚至是 Pygame book 都停留在入門的程度。為了達到更高的水準，我決定自己寫一套教學文件，希望可以為那些使用Pygame的朋友提供進階的學習。 這份教學鼓勵讀者去把玩程式碼，也非常建議對最後的練習題作些功課。這樣作可以讓你對這些教學有更好的瞭解。 預備知識 因為我在前面提過的理由，這份教學並不是給完全的初學者閱讀的。如果你才開始接觸 Pygame，先到這個 網頁 裡看一些基本的教學。這份 教學 也很適合初學Pygame。 在這篇文章，我假設你有下列知識：     >>Python(你不必是進階使用者，但也不能是完全的菜鳥)     >>基本的數學與物理（向量、矩形、運動定律、機率等等）。我會解釋所有不那麼明顯的部份，但我不會教你如何對向量作加法。     >>對Pygame有一些瞭解。你至少必須有瀏覽過在上面提到的教學裡的例子。 喔，還有一件事...這份教學主要考慮2D遊戲。3D有著另一層的困難度，我以後會提出一個自行開發一部份、簡單、不過足夠完整的3D demo。 我們開始吧！ 在這個部份，我們最後會完成一個模擬 - 有著在地上爬的小生物，會蠕動，然後碰到牆壁也會反彈，並偶而改變它們的行進方向： 這當然不是一個遊戲，不過卻是一個很有用的開頭，讓我們可以實作不同的想法。我延遲給出這個遊戲最終會變成的模樣，當作給我自己的奢侈享受。 程式碼 part 1的完整程式碼...
張貼留言
閱讀完整內容