中華大學

(1)

中華大學碩士論文

找出網路串流中最頻繁的項目及其電路實做 Finding Heavy-Hitter from Network Streams and

Its Hardware Implementation

系所別：電機工程學系碩士班學號姓名：M09701018 吳延鵬指導教授：謝坤融博士

高曜煌博士

(2)

摘要

如何有效率並且準確的找出網路串流中最頻繁出現的項目，這是一門很大的挑戰課題，本篇論文提出一種新的演算法，可以適用於即時的高速網路中，並且隨時紀錄著目前最高流量項目的前幾名，隨之使用少量的儲存空間，與極短的運算時間。先透過軟體的模擬測試，顯示我們的方法比起傳統的作法，能夠得到更高的準確率，最後再透過硬體來實現，且更可以支援超過兩條1 Gbps的網路流量。

關鍵字:網路串流、頻繁項目、高速網路、最高流量。

(3)

ABSTRACT

How to find frequent items of efficiently and accurately from network streams, this is a great challenge topic, this paper will propose a new algorithm, can be applied to real-time and high-speed network, has recorded of the current the maximum flow rate topic several, and spend very little resources space and the required computing time is also fixed.First we through simulation test use of software,illustrate our approch compared to traditional practices,can be get higher accuracy,finally we can use hardware implementation,but also supports more than two network 1 Gbps of network traffic.

Keywords: network streams、Heavy-Hitter、frequent items、network traffic

(4)

誌謝

首先感謝，謝坤融老師這兩年來的提攜與耐心指導，讓我在數位 IC 設計的領域

中大有所長，也增添了我對於這一方面濃厚的興趣，而老師總是在我遇到困難的瓶頸時，盡力的伸出援手來幫忙我，也讓我在人生的旅途與學習中，獲得更寶貴的建議，

在於心中更有著說不完的感謝，最後還是誠心的與老師您說一聲：老師謝謝您！！

另一方面也要感謝高曜煌老師的指導，讓我在生活中學習的更加順利，也謝謝父親、

母親、奶奶、姑姑，弟弟、妹妹，在精神上的加油與鼓勵，更要謝謝小叔與二叔在我生活上的支持與付出，讓我在學習時，對於生活上可以無後顧之憂，同時也感謝同學，

峪寬、雯惠，在這兩年中，一起做研究與熬夜的日子，相信日後大家都能一帆風順，

同時也謝謝 DSP 通訊實驗室的同學，偉懿、賢俊、名偉、權祐、以及學弟，建州、

孟勤、佳瑋、華智，佳龍、一喬，的鼓勵與互相打氣，讓我在碩士這兩年的學習得已順利完成。

吳延鵬中華民國九十九年七月 DSP 通訊實驗室

(5)

目錄

摘要 ... i

Abstract ... ii

誌謝 ... iii

目錄……….…….…………..

iv

表目錄……….….

vi

圖目錄……….………..…

vii

第一章緒論 ...

1

1.1 研究背景 ... 1

1.2 研究動機與目的... 2

1.3 論文章節概述 ... 2

第二章文獻回顧 ...

3

2.1 Majority 演算法 ... 3

2.2 Frequent 演算法 ... 4

2.3 Space-Saving 演算法 ... 5

2.4 Sketch 演算法 ... 7

第三章研究方法 ...

8

3.1 使用演算法 ... 8

3.2 改進方法與優點 ... 10

3.2.1 Change Table ... 10

3.2.2 真實票數（K） ... 11

3.3 模擬分析 ... 12

(6)

3.4.1 完整 Block ... 14

3.4.2 主要控制電路（Main Control） ... 15

3.4.3 Change Table ... 18

3.4.4 Rank Table ... 19

3.5 硬體模擬結果 ... 21

3.5.1 Change Table 模擬測試 ... 22

3.5.2 Rank Table 模擬測試 ... 27

3.5.3 Main Control 模擬測試 ... 34

3.5.4 完整電路模擬與測試結果 ... 36

第四章結論 ...

40

4.1 結論 ... 40

4.2 未來展望 ... 40

參考文獻 ...

41

附錄 ...

43

(7)

表目錄

表 2.4-1、Sketch 演算法示意表 ... 7

表 3.3-1、CASE1~4 模擬結果表 ... 13

表 3.5.4- 1、控制 Lookup_rank、Lookup_change 信號模擬統計表……….…..38

表 3.5.4-2、控制 add_rank、add_change 信號模擬統計表 ... 39

(8)

圖目錄

圖 2.1-1、Majority 演算法示意圖 ... 4

圖 2.2- 1、Frequent 演算法示意圖 4

圖 2.3- 1、Space-Saving 演算法示意圖 5 圖 2.3-2、多取 N 名 ... 6

圖 3.1- 1、系統架構圖 8

圖 3.2.1- 1、Change Table 架構圖 10

圖 3.3- 1、IP 票數集中分佈圖 12

圖 3.4- 1、硬體架構圖 14

圖 3.4.1- 1、完整電路 Block 15

圖 3.4.2- 1、Main Control 與 Change Table 方塊圖 16

圖 3.4.2-2、Main Control 與 Rank Table 方塊圖 ... 16

圖 3.4.2-3、Main Control State Transition 圖 ... 17

圖 3.4.3- 1、Change Table State Transition 圖 19

圖 3.4.4- 1、Rank Table State Transition 圖 21

圖 3.5.1- 1、Lookup_Change CASE 1 電路時序圖 23

圖 3.5.1- 2、Lookup_Change CASE 2 電路時序圖 ... 23

圖 3.5.1- 5、Add_Change CASE 1 電路時序圖 ... 25

圖 3.5.2- 1、Lookup_rank CASE 1、落在 TOP 1 電路時序圖 28

圖 3.5.2- 2、Lookup_rank CASE 2、原排名不動電路時序圖 ... 28

(9)

圖 3.5.2- 3、Lookup_rank CASE 2、排名上升 1 名電路時序圖 ... 29

圖 3.5.2- 4、Lookup_rank CASE 2、排名上升至 TOP 1 電路時序圖 ... 30

圖 3.5.2- 5、Lookup_rank 失敗 CASE 3、原排名不動電路時序圖 ... 30

圖 3.5.2- 6、Lookup_rank 失敗 CASE 3、排名上升 1 名電路時序圖 ... 31

圖 3.5.2- 7、Lookup_rank 失敗 CASE 3、排名上升至 TOP 1 電路時序圖 ... 32

圖 3.5.2- 8、Add_rank CASE 4 電路時序圖 ... 32

圖 3.5.3- 1、CASE 1 電路時序圖 34

圖 3.5.3-2、CASE2 電路時序圖 ... 34

圖 3.5.3-3、CASE3 電路時序圖 ... 35

圖 3.5.3-4、CASE4 電路時序圖 ... 35

圖 3.5.3-5、CASE5 電路時序圖 ... 36

圖 3.5.4- 1、CASE 1 電路時序圖 37

圖 3.5.4-2、CASE2 電路時序圖 ... 38

附錄- 1、完整電路方塊圖...51

(10)

第一章緒論

1.1 研究背景

鑑於今日高速網路普及化，使之網際網路的使用量與日俱增，根據 Cisco 研究調查，目前全球網路用戶平均每月使用 11.4Gbytes 的網路傳輸量，這不僅僅代表著網路大眾化，進而是使用率的大幅提昇，在如此大流量的網路串流中，更隱含著，網路封包所夾帶的資料，與訊息。

然而網路用戶最常使用的功能即是查詢的動作，根據 Google 與 Yahoo 再 2010 年 6～7 月之間，非重要關鍵字查詢就達全部關鍵字的 73.73%，想見在搜尋時，網路封包中所包涵的重要關鍵字，在查詢的動作中佔了相當大的地位。

在網路串流封包裡，找出最頻繁的項目，近年來，也逐漸日興越異，要有效並且快速的找尋到我們所要得目標，並不是一件簡單的事，舉例來說，當我們查詢 H1N1，

或許它會出現的是有關化學、醫學、或者歷史…等，並不一定是我們所要查詢的相關資料。

要在廣大的封包資料中找出最頻繁的項目，尤其應用於目的地的 IP，實為更艱鉅，以目前 Ipv4 位址的範圍就有 2³²之多，假使其中某個 IP 位址瞬間變成最熱門的目的地 IP，那此 IP 很有可能正遭受到 DDos 攻擊，如此一來要正確的找出實為一大課題。

(11)

1.2 研究動機與目的

在網際網路的大量使用之下，網路流量的控管，何其重要，尤其是在目的地的 IP 位址，加上近年來，DDos 的攻擊猖獗，使的找出最頻繁出現的 IP 位址為首要目的，

不只是針對於網路攻擊，在於 IP 流量管制，資料統計，搜尋管理，都是其主要目標。

以目前的文獻研究，找到最頻繁的項目，一般都只能達到快速處理，或者準確找出最高流量目的地 IP 的尋獲，兩者皆不相顧，就於快速找出最頻繁 IP，也有許多限制因素，否則也難正確的找出，相對的正確率就不高，另一則為準確率高，但所花費的儲存空間就越大，成本就越之昂貴，我們目的在於整合兩總型態的優點，進而改善其研究方法，為其我們的主要目的。

1.3 論文章節概述

本篇論文共分為 4 個章節：第一章為緒論，講述本篇論文研究的背景與研究動機。

第二章說明曾經研究此課題的文獻探討。第三章為本篇論文的核心，主要在說明我們改進後的演算法，與其利用軟體模擬的結果數據，接著再寫出使用改進後的演算法也可套用於硬體實現，並且利用硬體模擬出改善後的演算法的成效與其成果。第四章為結論，說明此議題的總結與未來的發展方向。

(12)

第二章文獻回顧

在網路串流裡找出最頻繁出現的項目，至從 1980 年代起就開始有人研究此課題，

截至目前為止相關研究大致可分類為兩大類：第一類是以 counter 為基礎的相關投票法，最早由 Moore 和 Boyer 在 1981 年所提出的 Majority 演算法 [1]，來處理這項問題。第二類是以 Sketch 為主 [2]，近些年以來陸續有些論文將第一類的方法擴展至尋找 TOP N 的應用，後續論文中我們將介紹這兩大類的方法與其它的優缺點。

2.1 Majority 演算法

於 1981 年由 Moore 和 Boyer 所提出的 Majority 演算法[1]，此演算法的概念與所需要運算的都很簡單，如圖 2.1-1，它主要精神就像是投票的多數決一樣，此演算法主要紀錄有兩項，一項為目前出現最多的項目，另一項是出現最多次項目的票數，它的運算系統很簡單化，如圖 2.1-1，當一個新進的項目進來時，如果與目前最多票數的項目一樣就將其項目的票數加 1 票，若不同，則要近一步判斷，假使目前領先的項目票數為 0，則將新進資料更換為領先的項目，並將它的票數設定為 1 票，反之領先項目的票數不為 0，就將目前領先項目的票數減 1 即可。

就於 Majority 演算法來說，它的優點在於使用少量的記憶體空間，簡單化的運算系統，但相對的，它的缺點在很多種狀況下，很難正確的尋找出正確的項目。以最典型的例子來說，當最多項目的票數未達到總票數的 1/2 時，與另一重要因素為資料進來的先後順序對其結果也有相當大的影響，在這些環境干擾因素之下，Majority 演算就會有很大的機率沒辦法找出正確的結果。

由於 Majority 演算法當初單純只有考慮，找出最高票的項目，尚未擴展到查詢最高票數的 N 個項目，後續許多論文也當將由此觀點出發，進而發展到查詢 TOP N 的方法。

(13)

2.2

et al.

點，將以及

票數中，反票時

Freq

延續 Majo . [4] 在 200 將主要精神及 TOP N 項目

當一筆新資數加 1 票。否

反之，將 T 時，就將此筆

B 1 A

quent 演

rity 演算法 03 年分別提神放在隨時保

目的票數。

資料進來時否則，若目前

TOP N 的每筆項目從 T

B 2 B

圖 2.1- 1、

演算法

法，將其擴展提出稱為 Fr 保持 N 筆紀

。

時，如圖 2.2 前紀錄的項每筆紀錄的票

TOP N 中踢

圖 2.2- 1、

B 1 B

、Majority 演

展至 TOP N，

requent 的演紀錄，每筆紀

2-1，如果此項目尚未達到

票數減 1，當除，由新進

、Frequent 演

A

0 T

演算法示意

，由 Demain 演算法，他紀錄都是包

此筆資料已到 N 筆，就當 TOP N 中進項目取代

演算法示意

A

1 F

意圖

ne et al. [3]

他們延用 Ma 包含目前屬於

已存在 TOP N 就直接將新進

中的某些項代。

意圖

A

2 A

在 2002 年 ajority 演算於 TOP N 的

N 中，則將進項目加入項目票數已被

A 項

1 票

A

年和 Karp 算法的優

的項目，

將此項目入 TOP N 被減至 0

項目

票數

(14)

2.3 Space-Saving 演算法

Metwally et al. [5] 在 2005 年所提出一種稱為 Space‐Saving 的演算法以下我們簡稱為 SS 演算法。此演算法近似於 Frequent 演算法，它也是紀錄每筆資料的項目與其票數，當一筆新進資料進來時並且落在 TOP N 中，如圖 2.3-1，也是將其項目的票數加 1，而最大不同在於當 SS 演算法在處理最後一名的方式是使用，當一筆新進資料為落在 TOP N 之內時，將此筆資料取代最後一名並且把它票數加 1，而原本的最後一名直接踢除於 TOP N 之外。

此篇 SS 演算法，也是本篇論文採用進而改善的方法，由原始 SS 論文得知，此演算法要能正確的找出結果，必須要在幾個因素之下，一為 TOP N 得票數必須大於總票數的 1/2，另一則為票數必需要是 Zipf 分佈型態，即是 TOP N 名之間的票數需為各自的 2 倍，如此才能提高正確結果的機率，另外尚有新進資料的順序也是造成正確率高低的重要一環。

圖 2.3- 1、Space-Saving 演算法示意圖

項目票數項目票數

A

100

A

100

B

⁵⁰

B

⁵¹

. . .

C

10

C

10

項目票數項目票數

A

¹⁰⁰

A

¹⁰⁰

B

50

B

50

. . .

C

10

K

11

B

K

(15)

由 SS 演算法，得知其利用多取 N 名的方法，如圖 2.3-2，來提昇它的正確率，

讓所要找尋最常出現的項目，有機會拉回真正的 TOP N 中，不至於讓 TOP N 中的項目，擠不回來，而 SS 演算法使用此方式，證實可以提高它的機率，然而我們也利用此優點，加入在我們改進的方法之中，如此一來，更能提昇我們所改進的方法，讓我們尋找真正最頻繁出現的項目可以順利找出，而不會因為此演算法的缺點，導致整體的正確率下降。

圖 2.3- 2、多取 N 名

(16)

2.4 Sketch 演算法

在這一類方法中，主要由 Charikar et al. [6] 在 2002 年所提出。其主要的作法是把 TOP N 出現的次數紀錄於 heap 之中，在加上一個 t x b 的計數器，來儲存所有項目出現的預估值，而這些 t x b 的計數器就稱之為 Sketch，見表 2.4-1。

當一筆新進資料進入若它屬於 TOP N，就將 heap 中該項目出現的次數加 1，若不屬於 TOP N，則將其出現的預估次數取出，若取出的預估值大於 heap 中 TOP N 出現的次數時，就將此筆資料放進 heap 裏，並且把 heap 裡 TOP N 次數最少的項目踢除。

Sketch 最主要功能在於 t x b 的計數器，它能有效的紀錄所有項目出現的出現次數。

而 Sketch 主要的維護方式，主要透過 2t 個 hash 函數 hi()和 si()來達成，i = 1 .. t。其 中 hi()的值為{1, .. , b}，而 si()的值為{+1, ‐1}。假設 q 為新進的項目，則依下述式子修 改 sketch 內容：h_i(q) = hi(q) + si(q)，對所有的 i = 1 .. t。若要算 q 的出現次數，則求 mediani{ hi(q)‧si(q)}即可。

其主要優點在於能夠準確的找出最常出現的項目，但其所耗費的空間也相對放大，

其次就是 Sketch 的處理運算時間也跟著隨之加長，這些在於未來發展的需求，尚需看使用者的衡量。

表 2.4- 1、Sketch 演算法示意表

TOP1 100

TOP2 99

TOP3 95

TOP1 101

TOP2 99

TOP3 95 M1

90 N1

80 P1

75

M1 90

N1 80

P1 75 Q1

70 R1

50 K1

110

Q1 70

R1 50

K1 110

TOP 1 TOP 2 TOP 3 TOP 1 TOP 2 TOP 3

A1 B1 C1 A1 B1 C1

TOP1 100

TOP2 99

TOP3 95

TOP1 110

TOP2 99

TOP3 95 M1

90 N1

80 P1

75

M1 90

N1 80

P1 75 Q1

70 R1

50 K1

110

Q1 70

R1 50

C1 95

TOP 1 TOP 2 TOP 3 TOP 1 TOP 2 TOP 3

A1 B1 C1 K1 A1 B1

A1

K1

(17)

3.1

路，我的的以便整體

紀錄篇論

使用演

我們的演算我們的應用的網路環境裡便日後查詢體的架構，如

在現今的網錄一次，那當論文以取 TO

演算法

算法是根據用是利用改良

裡，每秒鐘

，且節省空如圖 3.1-1，

網路環境裡當在查詢時 OP 5 名為例

第三章

據 Space-Sav 良後的演算鐘所接收傳送空間，並提昇

，這都是本裡，使用的 I 時，所消耗的

例，使用改善

圖 3

章研

ve 演算法(S 算法使用在

送的封包，

昇 Space-Sa 本篇論文演算

IP 數量非常的時間，將會

善後的方法

.1- 1、系統

研究方法

SS)，去改進在處理大量封可達 Gbps ave 計算大流算法的改良常多，如果會非常允長法呈現及其效

統架構圖

法

進其缺點，研封包的資料

s 以上，要如流量封包的良之一。

果每一個新的長，而且耗費

效能。

研究環境設料環境中，在如何有效率的準確度，且

的 IP 進來，

費大量的空

設定為網在大流量率的紀錄且簡化

我們就空間，本

(18)

因為 Space-Save(SS)的計算方式，取決於投票法，並且票數是取多數決，導致進來 TOP 1 的 IP 票數必須大於總票數的一半，才能正確的找出 TOP 1，然而我們利用投票法的準則，進而多增加了兩個欄位來紀錄每個 IP 的資訊，一個是 K 值，即它的真實票數，一則為 CB 值，即它的置換數，每個 IP 進來一次它的票數就加 1 票，而它的真實票數 K=Votes-CB，此為我們可以準確的計算出每個 IP 的真正票數，當排名內的 IP 被置換過，我們就把 CB 值加 1。

由於 Space-Save(SS)，只能算出最高票數的 IP，我們進而針對 SS 演算法加上了兩種改進的方式，使得 SS 演算法的缺點，可以得到大幅的改善，並且我們也保留了 SS 的優點，僅讓我們以少量的資源就可以達成，在加上 SS 只能在 Zipf 的分佈下才能準確的算出 TOP N，我們的方法也克服了此障礙，讓我們在非 Zipf 分佈時，也能準確的找出 TOP N。

Zipf 分佈，即是 TOP N 的票數必須大於總票數的一半以上，並且每一名之間的票數都必須相差為 2 倍的票數，在此環境下，SS 才能提高找出 TOP N 的準確率。我們使用軟體模擬出來的結果證實，我們的方法確實可以在非 Zipf 分佈時，一樣能快速且準確的找出 TOP N 的 IP。

由於在高速的網路環境之下，IP 的變動性非常迅速，只要 TOP N 之間的票數落差很小，TOP N 的排名隨時就會改變，所以 SS 演算法在每一名票數相差不大時，就很難找出正確的排名，反之每一名之間相差的票數越懸殊，SS 錯誤率才會明顯下降，

我們改進後所新增的 K 值與 CB 值，對於這個缺點有非常顯著的幫助能讓整體的準確度大幅的提昇。

K 值，即所謂的真實票數，因為 SS 所計算的票數都是不斷的置換 IP 所累積上去的虛值票數，並不是它的真實票數，我們利用 CB 這個數值來代表被置換過的 IP 次數，此可以確保，不同 IP 置換過所帶來的不實票數，然而我們排名的依據是利用 K 值來做真正的排名計算。

(19)

3.2 改進方法與優點

3.2.1 Change Table

經由上述 3.1 的方法在往下繼續延伸，除了多幾個存放空間給它之外，我們再加上一個 Change Table 的機制，如圖 3.2.2-1，此組機制最主要的是紀錄當在上述的方法時，於 TOP 10 的 IP 被踢除掉的同時，我們計算出被踢除的時候，它的 K 值為多少，我們只紀錄當 K 值大於 2 的時候，才把此組 IP 的票數與 CB 數存放到此 Table 中，而 K 值小於 2 時，我們就不做紀錄，直接刪除，在於 K 值取決於多少，需要看所取的 TOP N 的數量與總票數為主要參考依據，當取 TOP N 數的名次越多時，K 值就越小，反之，K 值就越大。

當被踢除的 IP 它的 K 值大於 2，我們紀錄在此 Table 中，在此 Table 中我們也是依其 K 值來做排名，當被丟進此 Table 時，如果其 K 值未大於其中的最後一名，我們也將不採取紀錄，而直接丟棄。

而在一個新進的 IP，在此組 Table 中查詢到時，我們就直接把此組 IP 當時在 Table 中的資料加回去 TOP 10 中，並且把它的票數＋1 票，CB 值不動，如果當時加回去時它的 K 值未大於 TOP 10 中的最後一名，就直接再加回 Change Table 裡，並繼續等待新進的 IP。

(20)

3.2.2 真實票數（K）

此為本篇可以準確的計算出它的排名核心，以原始的 SS 演算法，並不能算

出它原始的票數，但我們使用了 K 值，可以使 TOP 5 逼近它原本的真實票數，我們在 TOP 5 的排名依據是 K 值的大小做排名，當在 TOP 5 中有被踢除的 IP，判斷它是否要被加入到 Change Table 中，也是利用 K 值來做條件式判斷，在 Change Table 裡的排名亦是如此

這邊我們利用這 K 值的原理，大幅的改善，SS 演算法的漏洞，當一連串進來的 IP 皆為不同的時候，SS 會不斷的把票數累計上去，這些虛有的票數都是來自連續不同的 IP 進來所造成，這樣一來導致真實票數的失真，此因這一大缺點，我們引進了真實票數（K）的新概念來改善此失真的現象，為的就是要確保每一個新進 IP 的真實票數(式 3.1)。

K = Votes – CB

^{(式 3.1)}

(21)

3.3 模擬分析

我們利用軟體模擬在網路環境中 [7]，IP 進來的時間順序不同，在根據前五名佔總票數的不同，對 SS 與我們的改進方法做比較，且在真實環境裡，IP 進來的順序，

如圖 3.3-1，對結果的影響也有很大的因素，所以我們模擬測試 IP 進來的時間區分與總票數所佔的不同百分比，環境設定為 200 個不同 IP 進來，最高票數為 527 票，最低票為 1 票，並且針對包括下列四種不同的 Case，如圖 3.3-1，做模擬與分析。

Case 1：TOP 5 的 IP 票數集中在總票數的時間中斷進來，並且 TOP 5 的總票數佔 80%。

Case 2：TOP 5 的 IP 票數集中在總票數的時間前段進來，並且 TOP 5 的總票數佔 80%。

Case 3：TOP 5 的 IP 票數集中在總票數的時間後段進來，並且 TOP 5 的總票數佔 80%。

Case 4：TOP 5 的 IP 票數不集中在且分散隨時間平均進來，並且 TOP 5 的總票數佔 80%。

圖 3.3- 1、IP 票數集中分佈圖

(22)

經由模擬結果顯示 [8]，我們改進的方法對於這 4 種 Case 的準確率，在前 5 名佔總票數的 50%時，在每一種 Case 之下都能達到非常高的準確率，如表 3.3-1，相較於 SS 的演算法在 Case 2 與 Case 4 時的準確度，是沒辦法正確的找出。

本方法克服了原本的 SS 演算法只能在 Zipf 分佈時才能達到真正的準確率，進而在非 Zipf 分佈時，也能準確的找出 TOP N，在此我們所強調的是在非 Zipf 分佈時，

我們的性能與準確度整體上而言，我們所改進的方法，都優於 SS 演算法。

前 5 名票數佔總票數 6.2% 前 5 名票數佔總票數 50%

Method

改善後演算法 Space Saving

Method

正確率順序全對正確率順序全對正確率順序全對正確率順序全對

Case 1 0% 0% 0% 0% Case 1 100% 87.3% 100% 80.3%

Case 2 95.2% 78.4% 0% 0% Case 2 100% 100% 0% 0%

Case 3 0% 0% 0% 0% Case 3 100% 80.8% 100% 78%

Case 4 100% 99.4% 0% 0% Case 4 100% 100% 0% 0%

前 5 名票數佔總票數 33% 前 5 名票數佔總票數 90%

Method

正確率順序全對正確率順序全對正確率順序全對正確率順序全對

Case 1 82.8% 28.8% 0% 0% Case 1 100% 100% 100% 100%

Case 2 100% 100% 0% 0% Case 2 100% 100% 100% 100%

Case 3 82.6% 14.3% 100% 76.4% Case 3 100% 100% 100% 100%

Case 4 100% 100% 0% 0% Case 4 100% 100% 100% 100%

表 3.3- 1、CASE1~4 模擬結果表

(23)

3.4 硬體實現

我們先經由 PC 端利用乙太網路與 FPGA 電路板之乙太網路卡做連接，如圖 3.4-1 所示，發送我們所要模擬的 IP 資料至 FPGA 之中，先經由 FPGA 的乙太網路卡接收之下，經過網路協定的動作之後，再透過 MII(Mida Independent Interface)介面 [9,10]，

可以找出所要得封包資料(IP)，再送至我們所改良演算法電路中運算出所要尋找的 TOP N，存放至 RAM 中，最後由 RAM 中讀出所要尋找最頻繁的 TOP N 項目即目的地 IP。

本篇電路使用 Verilog 硬體描述語言來撰寫 [11,12]，並且再使用電路模擬軟體 ModelSim 來模擬我們的方法運算結果是否正確，接著再利用 Xilinx 電路合成軟體 [13]，把我們所撰寫後的電路程式合成為一塊數位電路，再把電路燒錄至 ML505 此 塊 FPGA 電路開發板中，並模擬出我們改進後的演算法與其結果。

圖 3.4- 1、硬體架構圖

3.4.1 完整 Block

在此敘述每個 Block，與每塊電路的 State，可以把整個完整 Block，如圖 3.4.1-1，

(24)

是來計算且存放 TOP N 的區塊，而 Change Table 是用來存放從 Rank Table 中所被踢除的 IP 資料，並且產生兩塊測試的 RAM 來存放 Rank Tabe 與 Change Table 運算出來的排名結果。

我們重點將放在改良後的演算法也可有效的應用在電路上執行，並利用電路的高速處理優點，更能突顯我們改進後的方法在電路中也能準確的找出我們要的 TOP N，

主要電路設計共分為 3 大區塊，以下我們將細部說明每一區塊電路的結構及其模擬成效。

圖 3.4.1- 1、完整電路 Block

3.4.2 主要控制電路（Main Control）

此塊控制電路主要在控制，當一個新的 IP 進來的同時，利用 lookup_change 這根信號，先送至 Change Table，如圖 3.4.2-1，裡查詢此組 IP 是否已存在 Table 中，如果查詢到回傳 1，若無則回傳 0，當有查詢到時，再利用 add_rank 這根信號，去通知 Rank Table，如圖 3.4.2-2，把此組 IP 資料回加到 Rank Table 中，並且把 Change Table 查詢到的 IP 票數＋1 回傳，而在 Rank Table 裡會回傳最後一名的資料，再控制 add_change 這根信號，去通知 Change Table，把從 Rank Table 回送的資料加進去 Change Table 裡，如果在 Change Table 裡查詢不到，再使用 lookup_rank 這根信號去查詢新進

Main Control

Rank Table

Change Table

IP

Rank RAM

Change

RAM

(25)

IP 是否有存在 Rank Table 中，如果存在 Rank Table 中，可利用 rank_in 這根信號，知道此組 IP 在 Rank Table 裡的排名是多少，再把此排名用 rank_n 回送到 Rank Table 讓 Rank Table 知道把此組 IP 的票數加在哪，在 Change Table 與 Rank Table 都完成時，

rdy_change 與 rdy_rank 這兩根信號回去通知控制電路動作已完成，在整個控制流程結束後再讓 rdy_control 此根信號為 1，表示所有動作皆已完成，讓新 IP 可以再送進來。

圖 3.4.2- 1、Main Control 與 Change Table 方塊圖

Main Control

lookup_change ip_change_out add_change

write_change_data found_change read_change_data rdy_change clk

reset trigger

ip rdy_control

lookup_change ip add_change write_change_data

found_change read_change_data

rdy_change

Change Table

Main Control

lookup_rank ip_rank_out add_rank rank_n

write_rank_data found_rank rank_in

read_rank_data rdy_rank

clk reset trigger

ip

rdy_control

Rank Table

lookup_rank ip add_rank

rank_in write_rank_data

found_rank rank_out read_rank_data

rdy_rank

(26)

而在控制電路中，使用 State Machine 來做所有的電路控制，共分為 7 個 state，

分別是，如圖 3.4.2-3：

0- Idle：State 的初始狀態，所有路徑的開始，也是最後的回歸點。

1- R_change：控制 lookup_change，去 Change Table 中查詢 IP 是否存在。

2- Add_rank：控制 add_rank，在 Change Table 中查詢到 IP，把此組 IP 加回 Rank Table 中，並等待 rdy_rank。

3- Decide_RK：判斷 Rank Table 回送回來最後一名的 K 值，或者從 Change Table 中加回 Rank Table 失敗，再回傳回來 IP 的 K 值，並且控制 add_change、rdy_control。

4- R_rank：控制 lookup_rank，去 Rank Table 中查詢 IP 是否存在。

5- Decide_K：判斷 Rank Table 中回傳最後一名的 K 值，是否要加入到 Change Table 中，

並且控制 add_change、rdy_control。

6- Add_change：等待 rdy_change，並且控制 rdy_control。

藉由上述的 7 個 State，即可把 Change Table、Rank Table，兩塊紀錄排名 Table 的 IP 資料控制它門的流向，不至於在運算過程中把 IP 存放到錯的 Table 中。

圖 3.4.2- 3、Main Control State Transition 圖

Found = 1

Found = 0 K > 2

K < 2

K > 2 K < 2

Found = 1

Found = 0

(27)

3.4.3 Change Table

此 Change Table 的機制，最重要的就是在防止真正的 TOP 5，因為 SS 演算法的缺點而把它踢除，在這個機制當中，只要 TOP 5 的 IP 再次進來，我們都還能夠把它拉回 Rank Table 裡，而要加入到此 Table 中，基本條件必須要滿足 K 值大於 2，此 K 值為了避免隨意一組 IP 就能夠任意的加入，此是為了提昇，存放真正 TOP 5 的機會，

並且在 Table 也是利用 K 值大小來做排名，當新進 IP 進來時，在此 Table 中查詢到已存在，此筆 IP 被加回 Rank Table 之後，我們就會把此組 IP 從 Table 中做刪除的動做，

並且從新做一次排名的動作。

首先我們利用 lookup_change，先在 Table 中查詢，如果查詢到的同時，我們回傳此筆 IP 資料，並且刪除此筆資料，當有資料要加入進來時，再利用 add_change，來看要加入的此筆資料，要加入到排名多少，或者是否要加入，每做完一次循環，在讓 rdy_change，去通知 main control，在 Change Table 這個機制中，已完成所有動作，可以繼續送下一筆 IP 進來。

在此 Table 中，我們也是利用 State Machine，來做所有的電路動作控制，共分為 5 個 State，分別為，如圖 3.4.3-1：

1- Read_tbd：收到 lookup_change 時，至 RAM 中讀取目前的排名資訊，如果有讀到新進 IP 已存在，再利用 found_change 為 1 回傳通知，而跳往下個 State 為 write_de，如果沒讀到則跳回 Idle 等待下一筆 IP 的進入。

2- Write_de：去刪除 RAM 中，回傳的 IP 資料，並做重新排名的動作。

3- Read_tba：當 add_change 為 1 時，從 RAM 中讀取目前的排名資料，並且判斷是否新進 IP 的 K 值該加入到排名幾，或者不加入。

(28)

圖 3.4.3- 1、Change Table State Transition 圖

3.4.4 Rank Table

在此 Table 中，記錄著真正的 TOP 5 的 IP 資料，我們利用 SS 演算法的特點，可以快速的計算每一筆進來的 IP，再加上我們的改進，更能準確的增加每一筆資料的準確度。

當新進 IP 在 Change Table 裡未查尋到，我們在利用 lookup_rank，在此 Table 中，

查詢是否已有此筆紀錄，首先會先從 RAM 中讀取目前所有的排名資料，如果有存在此筆 IP，則將它的票數＋1 票，置換數（CB）值保持原本的值，再寫回 RAM 中，並且回傳 rdy_control 為 1，如果未查到此筆 IP，則把最後一名 IP 置換成新進 IP，並且把它的票數與置換數（CB）都各＋1，

再次寫回 RAM 中，同時，把最後一名的 IP、票數、置換數（CB），回傳至 Main Control，完成整個流程之後再利用 rdy_control、rdy_rank 通知 Main Control 在 Rank Table 已完成所有計算讀寫的動作，可以等待下一筆新 IP 的傳送。

Add_change = 1 lookup_change = 1

Found = 0

Found = 1

(29)

在此 Table 中，我們也是利用 State Machine，來做所有的電路動作控制，共分為 6 個 State，分別為，如圖 3.4.4-1：

1- Read_tbn：當 lookup_rank 時，至 RAM 中讀取目前所有的排名資料，並且判斷此新進 IP 是否已存在，如果存在 found_rank 為 1 通知 Main Control 已找到，並跳至下個 State 為 Write_found，如果為尋找到，found_rank 為 0，並跳到下個 State 為 Write_last。

2- Write_found：當 found_rank 為 1 時，將找到的 IP 資料做票數＋1，置換數（CB）不加的運算，再做重新排名的動作寫回 RAM 中。

3- Write_last：當 found_rank 為 0 時，做置換最後一名 IP 的動作，並且把此筆的票數與置換數（CB）各＋1，同時回傳最後一名的 IP 與它當時的票數與（CB）數，再重新做排名並寫回 RAM 中，且回傳 rdy_rank 通知 Main Control 已完成查詢寫入運算，下個 State 並回到 Idle。

4- Read_tba：當 add_rank 為 1 時，至 RAM 中讀取目前所有排名資料，並且下個 State 跳至 Write_tb。

5- Write_tb：判斷從 Change Table 中拉回 IP 的 K 值是否，大於排名中的 K 值，如果大於，寫入此筆 IP 的資料，且回傳最後一名的 IP 資料，並做重新排名的動作，若無大於，則回傳 Change Table 傳來的同一筆 IP 資料，完成整個動作之後再藉由 rdy_rank，

通知 Main Control，在 Rank Table 裡已完成判斷寫入運算，而下個 State 並回到 Idle 中。

(30)

圖 3.4.4- 1、Rank Table State Transition 圖

3.5 硬體模擬結果

為了確保每一塊電路皆能夠正常運作，所以必須在每塊電路加入測試資料，已避免日後 Debug 找不出問題所在，首先我們以小區塊電路測試為主要模擬，保證每塊電路的動作都沒問題之後，再將 3 塊電路全部接上，並且模擬這完整電路的正確性，

並且可以正確算出 TOP N，得以配合軟體模擬結果的準確性，以下我們將詳細的列出每一區塊電路的測試模擬結果。

lookup_rank = 1

Add_rank = 1

(31)

3.5.1 Change Table 模擬測試

ram.mem[0] = 96'h00000001_00000010_cccccccc; //k=15 ram.mem[1] = 96'h00000000_00000009_aaaaaaaa; //k=9 ram.mem[2] = 96'h00000002_00000009_dddddddd; //k=7 ram.mem[3] = 96'h00000004_00000009_eeeeeeee; //k=5 ram.mem[4] = 96'h00000006_00000009_ffffffff; //k=3

以上為我們放在測試 RAM 中的 IP [0~31 bit]、票數 [63~32 bit]、置換數（CB）

[95~63 bit]、與排名。

當 lookup_change 時：

write_change_data[95:0] = 96'h00000000_00000000_cccccccc;

//Top1

write_change_data[95:0] = 96'h00000000_00000000_aaaaaaaa; //Top2 write_change_data[95:0] = 96'h00000000_00000000_ffffffff;

//Top5

write_change_data[95:0] = 96'h00000000_00000000_bbbbbbbb; //no match

(32)

CASE 1、lookup_change 時，落在 TOP 1：

圖 3.5.1- 1、Lookup_Change CASE 1 電路時序圖 a. found_change 在讀到 TOP 1 時為 1。

b. read_change_data 為 96'h00000001_00000010_cccccccc;。

c. 在 state 為 2 時，把當時 TOP 2 寫入到 TOP 1，後面名次往上 Shift，並把最後一名寫入為 96'b0。

CASE 2、lookup_change 時，落在 TOP 2：

b. read_change_data 為 96'h00000000_00000009_aaaaaaaa;。

c. 在 state 為 2 時，把當時 TOP 3 寫入到 TOP 2，後面名次往上 Shift，並把最後一名寫入為 96'b0。

(33)

CASE 3、lookup_change 時，落在 TOP 5：

b. read_change_data 為 96'h00000006_00000009_ffffffff;。

c. 在 state 為 2 時，把 TOP 5 寫入為 96'b0。

CASE 4、lookup_change 時，未查詢到，NO Match：

圖 3.5.1- 4、Lookup_Change CASE 4 電路時序圖 a. found_change，因為未查詢到所以為 0。

b. read_change_data 為 96'h00000000_00000000_00000000;。

c. TOP 1~TOP 5 皆為 RAM 中的 TOP 1~TOP 5。

(34)

當 add_change 時：

write_change_data[95:0] = 96'h00000001_00000020_bbbbbbbb;//add in top1,k=1f write_change_data[95:0] = 96'h00000005_00000010_bbbbbbbb;//add in top2,k=11 write_change_data[95:0] = 96'h00000004_00000008_bbbbbbbb;//add in top5,k=4 write_change_data[95:0] = 96'h00000040_00000040_bbbbbbbb;//add fail ,k=0

CASE 1、add_change 時，落在 TOP 1：

圖 3.5.1- 5、Add_Change CASE 1 電路時序圖

a. 加入的 K 值大於 TOP 1，add_change 為 1，寫入 TOP 1，後面名次往下 shift。

b. read_change_data 為 96'b0;。

CASE 2、add_change 時，落在 TOP 2：

圖 3.5.1- 6、Add_Change CASE 2 電路時序圖

a. 加入的 K 值大於 TOP 2，add_change 為 1，寫入 TOP 2，後面名次往下 shift。

(35)

CASE 3、add_change 時，落在 TOP 5：

圖 3.5.1- 7、Add_Change CASE 3 電路時序圖 a. 加入的 K 值大於 TOP 5，add_change 為 1，寫入 TOP 5。

CASE 4、add_change 為 0，加入失敗：

圖 3.5.1- 8、Add_Change CASE 4 電路時序圖 a. 加入的 K 值小於 TOP 5，加入失敗。

c. State 由 0 跳 3 讀取，再跳 4 寫入失敗，再回 Idle。

(36)

3.5.2 Rank Table 模擬測試

ram.mem[0] = 96'h00000001_00000015_33333333; //k=20

ram.mem[1] = 96'h00000001_00000013_aaaaaaaa; //k=18 ram.mem[2] = 96'h00000001_00000011_dddddddd; //k=16 ram.mem[3] = 96'h00000001_0000000f_eeeeeeee; //k=14 ram.mem[4] = 96'h00000001_0000000d_ffffffff; //k=12 ram.mem[5] = 96'h00000001_0000000b_88888888; //k=10 ram.mem[6] = 96'h00000001_00000009_99999999; //k=8 ram.mem[7] = 96'h00000001_00000007_55555555; //k=6 ram.mem[8] = 96'h00000001_00000005_11111111; //k=4 ram.mem[9] = 96'h00000001_00000003_77777777; //k=2 ram.mem[9] = 96'h00000001_00000005_77777777;//k=4 no find rank up one ram.mem[9] = 96'h00000002_00000016_77777777;//k=20 no find rank up top1

(37)

當 lookup_rank 時：

CASE 1、lookup_rank 時，落在 TOP 1：

Ⅰ：原排名不動（Ⅱ：上升 1 名次。Ⅲ：上升至 TOP 1。Ⅱ、Ⅲ與Ⅰ測試相同）

圖 3.5.2- 1、Lookup_rank CASE 1、落在 TOP 1 電路時序圖 Send data：ip = 32'h3333_3333;

write_rank_data[95:0] = 96'h00000001_00000016_33333333;

rank_in = 0;

a. 查詢到 TOP 1，read top1:ram.mem[0] = 96'h00000001_00000015_33333333;

寫回的票數為 16，置換數（CB）不變。

b. rank_out = 0，未查詢到時，IP 排名。

c. rank_in = 0，送回排名 TOP 1 裡的判斷，運算過後寫入 RAM。

CASE 2、lookup_rank 時，落在 TOP 10：

Ⅰ：原排名不動

(38)

Send data：ip = 32'h7777_7777;

write_rank_data[95:0] = 96'h00000001_00000004_77777777;

rank_in = 9;

a. 查詢到 TOP 10，read ram.mem[9]=96'h00000001_00000003_77777777;//k=2 寫回的票數為 4，置換數（CB）不變。

c. rank_in = 9，送回排名 TOP 10 裡的判斷，運算過後寫入 RAM。

Ⅱ：排名上升 1 名次

圖 3.5.2- 3、Lookup_rank CASE 2、排名上升 1 名電路時序圖 Send data：ip = 32'h7777_7777;

write_rank_data[95:0] = 96'h00000001_00000006_77777777;

rank_in = 9;

a. 查詢到 TOP 10，read ram.mem[9]=96'h00000001_00000003_77777777;//k=2 寫回的票數為 6（測試上升一名），置換數（CB）不變。

c. rank_in = 9，送回排名 TOP 10 裡的判斷，此筆 IP 寫入 TOP 9，而 TOP 9 寫入 TOP 10，最後後寫入 RAM。

(39)

Ⅲ：排名上升至 TOP 1

圖 3.5.2- 4、Lookup_rank CASE 2、排名上升至 TOP 1 電路時序圖 Send data：ip = 32'h7777_7777;

write_rank_data[95:0] = 96'h00000001_000000016_77777777;k=21 rank_in = 9;

a. 查詢到 TOP 10，read ram.mem[9]=96'h00000001_00000003_77777777;//k=2 寫回的票數為 16（測試上升至 TOP 1），置換數（CB）不變。

c. rank_in = 9，送回排名 TOP 10 裡的判斷，此筆 IP 寫入 TOP 1，後面名次依序往下 Shift 一名，最後一名 IP 是 11111111，為原本的 TOP 9，最後後寫入 RAM。

CASE 3、lookup_rank 失敗，未查詢到：

Ⅰ：原排名不動

(40)

Send data：ip = 32'h2222_2222;

a. 未查詢到回傳 TOP 10，ram.mem[9]=96'h00000001_00000003_77777777;//k=2 寫回的票數為 4，置換數（CB）為 2。

b. 原 TOP 10 的 IP 為 77777777，因未查詢到，最後一名 IP 置換為新進 IP。

Ⅱ：排名上升 1 名次

圖 3.5.2- 6、Lookup_rank 失敗 CASE 3、排名上升 1 名電路時序圖

Send data：ip = 32'h2222_2222;

測試初始狀態時與各名次的 k 值相同時,會不會寫入排名的變動

b. 原 TOP 10 的 IP 為 77777777，因未查詢到，最後一名 IP 置換為新進 IP，而原本 TOP 9 寫入 TOP 10，IP 為 11111111。

(41)

Ⅲ：排名上升至 TOP 1

圖 3.5.2- 7、Lookup_rank 失敗 CASE 3、排名上升至 TOP 1 電路時序圖 Send data：ip = 32'h2222_2222;

測試初始狀態時與各名次的 k 值相同時,會不會寫入排名的變動

b. 原 TOP 10 的 IP 為 77777777，因未查詢到，且 K 值上升至排名 TOP 1，並且至換成新 IP，原 TOP 1 寫入 TOP 2，後面名次依序往下 Shift 一名次。

CASE 4、add_rank 時，加至 TOP 10：

圖 3.5.2- 8、Add_rank CASE 4 電路時序圖從 changetb 送過來的資料為：

write_rank_data[95:0] = 96'h00000001_00000004_22222222;

(42)

CASE 5、add_rank 時，加至 TOP 1：

write_rank_data[95:0] = 96'h00000001_00000016_22222222;

a. K 值大於 TOP 1，所以會加入到 TOP 1，並且把最後一名的資料回傳。

b. TOP 1～TOP 9 名次依序往下 Shift 一名次，寫入 RAM。

CASE 6、add_rank 時，加入失敗：

write_rank_data[95:0] = 96'h00000001_00000002_22222222;

a. K 值未大於 TOP 10，所以加入失敗，並且回傳 changetb 送過來的資料。

b. TOP 1～TOP 10 名次未變動。

(43)

3.5.3 Main Control 模擬測試

為了確保我們的控制電路可以如我們所預期的達成所要的動作，在此塊電路上我們所要測試的目標在於控制電路中的每個 State 與 State 之間的路徑皆能順暢，

並且每條路徑都必須確保它皆能通過，以下我們將模擬在控制電路中的 p_state，

在每種狀況條件之下都能順利執行。

CASE 1、P_state 路徑為 0 → 1 → 2 → 3 → 0：

圖 3.5.3- 1、CASE 1 電路時序圖 a. 由時序圖中可以見得，在控制電路中，p_state 路徑為：

0 → 1 → 2 → 3 → 0 正確無誤。

CASE 2、P_state 路徑為 0 → 1 → 2 → 3 → 6 → 0：

(44)

a. 由時序圖中可以見得，在控制電路中，p_state 路徑為：

0 → 1 → 2 → 3 → 6 → 0 正確無誤。

CASE 3、P_state 路徑為 0 → 1 → 4 → 0：

圖 3.5.3- 3、CASE 3 電路時序圖 a. 由時序圖中可以見得，在控制電路中，p_state 路徑為：

0 → 1 → 4 → 0 正確無誤。

CASE 4、P_state 路徑為 0 → 1 → 4 → 5 → 0：

圖 3.5.3- 4、CASE 4 電路時序圖 a. 由時序圖中可以見得，在控制電路中，p_state 路徑為：

0 → 1 → 4 → 5 → 0 正確無誤。

(45)

CASE 5、P_state 路徑為 0 → 1 → 4 → 5 → 6 → 0：

圖 3.5.3- 5、CASE 5 電路時序圖

a. 由時序圖中可以見得，在控制電路中，p_state 路徑為：

0 → 1 → 4 → 5 → 6 → 0 正確無誤。

3.5.4 完整電路模擬與測試結果

我們經由上述小節的模擬與結果，確認每塊電路皆能正常動作，最後我們將所有電路連接，測試本篇論文之方法是能準確的找出我們所要得最頻繁項目。

CASE 1、IP 個數為 30 個，總票數為 320 票，TOP 5 總票數為 215 票：

TOP 1、IP：135.13.216.191 → 870dd8bf (16 進位) TOP 2、IP：172.16.115.5 → ac107305 (16 進位) TOP 3、IP：207.46.130.139 → cf2e828b (16 進位) TOP 4、IP：172.16.117.52 → ac107534 (16 進位) TOP 5、IP：172.16.114.148 → ac107294 (16 進位)

(46)

a. 測試資料為非 Zipf 分佈票數，可以看到我們的結果是完全相符的 TOP 1、IP：135.13.216.191 → 870dd8bf (16 進位)

TOP 2、IP：172.16.115.5 → ac107305 (16 進位) TOP 3、IP：207.46.130.139 → cf2e828b (16 進位) TOP 4、IP：172.16.117.52 → ac107534 (16 進位) TOP 5、IP：172.16.114.148 → ac107294 (16 進位)

CASE 2、IP 個數為 200 個，總票數為 4528 票，TOP 5 總票數為 2264 票：

TOP 1、IP：135.13.216.0 → 870dd800 (16 進位) TOP 2、IP：135.13.216.1 → 870dd801 (16 進位) TOP 3、IP：135.13.216.2 → 870dd802 (16 進位) TOP 4、IP：135.13.216.3 → 870dd803 (16 進位) TOP 5、IP：135.13.216.4 → 870dd804 (16 進位)

(47)

a. 測試資料為非 Zipf 分佈票數，可以看到我們的結果是完全相符的 TOP 1、IP：135.13.216.0 → 870dd800 (16 進位)

TOP 2、IP：135.13.216.1 → 870dd801 (16 進位) TOP 3、IP：135.13.216.2 → 870dd802 (16 進位) TOP 4、IP：135.13.216.3 → 870dd803 (16 進位) TOP 5、IP：135.13.216.4 → 870dd804 (16 進位)

經由上述幾個小節的模擬與測試，我們在 Change Table、Rank Table 中，模擬了 Lookup_change、Lookup_rank，見表 3.5.4-1，Add_change、Add_rank，見表 3.5.4-2，

此 4 根主要信號並且確認它們在時間點確實有開始動作。

lookup TOP 1 lookup TOP 10 lookup no found

Rank Table

排名不動排名不動 TOP 10 排名不動

上升 1 名上升 1 名 TOP 10 上升 1 名

上升至 TOP 1 上升至 TOP 1 TOP 10 上升至 TOP 1

lookup TOP 1 lookup TOP 5 lookup no found

Change Table

原排名 TOP 2→TOP 1 原排名 TOP 1→TOP 1 原排名 TOP 1→TOP 1 原排名 TOP 3→TOP 2 原排名 TOP 2→TOP 2 原排名 TOP 2→TOP 2 原排名 TOP 4→TOP 3 原排名 TOP 3→TOP 3 原排名 TOP 3→TOP 3 原排名 TOP 5→TOP 4 原排名 TOP 4→TOP 4 原排名 TOP 4→TOP 4

(48)

Add TOP 1 Add TOP 10 Add fail

Rank Table

原排名 TOP 1→TOP 2 原排名 TOP 1→TOP 1 原排名 TOP 1→TOP 1 原排名 TOP 2→TOP 3 原排名 TOP 2→TOP 2 原排名 TOP 2→TOP 2

. . .

原排名 TOP 9→TOP 10 新資料 → TOP 10 原排名 TOP 10→TOP 10

Add TOP 1 Add TOP 5 Add fail

Change Table

新資料 → TOP 1 原排名 TOP 1→TOP 1 原排名 TOP 1→TOP 1 原排名 TOP 1→TOP 2 原排名 TOP 2→TOP 2 原排名 TOP 2→TOP 2 原排名 TOP 2→TOP 3 原排名 TOP 3→TOP 3 原排名 TOP 3→TOP 3 原排名 TOP 3→TOP 4 原排名 TOP 4→TOP 4 原排名 TOP 4→TOP 4 原排名 TOP 4→TOP 5 新資料 → TOP 5 原排名 TOP 5→TOP 5 表 3.5.4- 2、控制 add_rank、add_change 信號模擬統計表

改進後方法，在電路上的使用，也能完全符合我們的預期，並且我們最後電路使用 Xilinx ISE，來做合成的部份，在 Main Control 的部份使用 260 個 register、280 個 LUTs、工作頻率在 594.669 MHz，在 Rank Table 的部份使用 1260 個 register、4328 個 LUTs、工作頻率在 243.798 MHz，在 Change Table 的部份使用 695 個 register、280 個 LUTs、工作頻率在 247.706 MHz，最後我們把 3 塊電路做合成，所得到的工作頻率在 179.134 MHz，而處理每筆資料，耗費 44 個時脈週期，大約是 245 ns 時間，所以每秒大約能處理 4 百萬個封包。而 2 Gbps 的乙太網路上，每秒傳輸的最大封包數大約在 3 百萬的封包，所以我們一組電路可以處理超過兩條 1 Gbps 的乙太網路。

(49)

第四章結論

4.1 結論

最後我們經由軟體模擬與電路模擬，證實我們的方法，是可行的，並且可以正確的找出網路串流中最頻繁出現的項目，並且使用少量的記憶體空間。我們改進原始 SS 演算法，也證實我們改進之後的方法克服了，SS 演算法在非 Zipf 分佈時，無法正確尋找出真正的 TOP N，並且我們最後的 K 值(真實票數)，是可以非常接近 TOP N 的真實票數。

4.2 未來展望

未來我們將可以利用在真實網路上的封包，作為驗證環境，進一步透視我們改進的演算法在實際網路上的應用與成效，此外也可將我們的方法繼續拓展到 change detection，並可以實際應用於入侵偵測，DDos 與蠕蟲攻擊等範疇，對於日後的高速網路更可使用於網路還原，讓原始網路裏的真相得以一清二楚。

(50)

參考文獻

[1] R. S. Boyer and J. S. Moore.MJRTY - a fast majority vote algorithm. In Automated

Reasoning: Essays in Honor of Woody Bledsoe,Automated Reasoning

Series,pages105-117.Kluwer Academic Publishers,1991.

[2] N. Alon, Y. Matias, and M. Szegedy. The space complexity of approximating the frequency moments. In ACM Symposium on Theory of Computing,page 20-29 1996.

[3] E. Demaine, A. L´opez-Ortiz, and J. I. Munro. Frequency estimation of internet packet streams with limited space. In European Symposium on Algorithms (ESA), 2002.

[4] R. Karp, C. Papadimitriou, and S. Shenker. A simple algorithm for finding frequent elements in sets and bags. ACM Transactions on Database Systems, 28:51-55, 2003.

[5] A. Metwally, D. Agrawal, and A. E. Abbadi. Efficient computation of frequent and top-k elements in data streams. In International Conference on Database Theory, 2005.

[6] M. Charikar, K. Chen, and M. Farach-Colton. Finding frequent items in data streams.

In Procedings of the International Colloquium on Automata, Languages and

Programming (ICALP), 2002.

[7] 吳延鵬、楊峪寬、謝坤融、高曜煌,“Finding Frequent Items from Network Streams,”

2010 電子工程技術研討會,2010.

[8] 楊峪寬, “在網路環境中有效率地尋找最常出現的項目,”中華大學碩士論文,2010.

[9] 施威銘研究室,【最新網路概論 2008】,旗標出版股份有限公司,2008,ISBN：

978-957-442-468-9

[10] 黃明祥,林詠章,【資訊與網路安全概論第二版】,美商麥格羅．希爾國際股份有

(51)

限公司台灣分公司,2007,ISBN：978-986-157-364-9

[11] SAMIR PALNITKAR,翻譯：黃英叡,黃稚存,【Verilog 硬體描述語言(第二版)】, 全華圖書,2009,ISBN：978-986-154-104-4

[12] 具再熙,【Verilog2001 及 SystemVerilog 入門指引】,全華圖書,2007,ISBN：

978-957-21-5719-0

[13] 鄭群星,【FPGA/CPLD 數位晶片設計入門-使用 Xilinx ISE 發展系統】,全華圖書,2005,ISBN：957-21-4856-7

(52)

附錄電路程式碼

module main_control

(clk,reset,trigger,ip,rdy_rank,rdy_change,re ad_rank_data,

read_change_data,add_rank,add_change,lo okup_rank,

lookup_change,rank_n,found_change, found_rank, rank_in,

write_rank_data,write_change_data,ip_cha nge_out,ip_rank_out,rdy_control);

input

clk,reset,trigger,rdy_rank,rdy_change,foun d_change, found_rank;

input [3:0] rank_in;

input [31:0] ip;

input [95:0]

read_rank_data,read_change_data;

//[31:0] ip //[63:32] ticket //[95:64] cb

//read_rank_data = rank tb Result //read_change_data = change tb Result output reg [95:0]

write_rank_data,write_change_data;//write _rank_data = send to rank tb

//wirte_change_data = send to change tb output reg

add_rank,add_change,lookup_rank,lookup _change;

output reg [31:0]

ip_change_out,ip_rank_out;

output reg [3:0] rank_n;

output reg rdy_control;

//output reg [31:0] ip_out;

localparam idle = 0;

localparam r_change = 1;

localparam add_rank_state = 2;

localparam decide_RK = 3;

localparam r_rank = 4;

localparam decide_K = 5;

localparam add_change_state = 6;

reg rdy_control_next;

reg [4:0] n_state;

reg [95:0]

write_change_data_next,write_rank_data_

next;

reg [31:0]

ip_change_out_next,ip_rank_out_next;

always @*

begin

lookup_rank = 0;

lookup_change = 0;

add_rank = 0;

add_change = 0;

rank_n = rank_in;

n_state = p_state;

write_rank_data_next = write_rank_data;

write_change_data_next = write_change_data;

ip_change_out_next = ip_change_out;

ip_rank_out_next = ip_rank_out;

rdy_control_next = 0;

case (p_state) idle: //0

if (trigger == 1) begin

n_state = r_change;

end

r_change: //1 begin

begin

lookup_change = 1;

ip_change_out_next[31:0] = ip[31:0];

end

if (rdy_change == 1) if (found_change == 1) begin

write_rank_data_next[31:0] = read_change_data[31:0];

write_rank_data_next[63:32] =

read_change_data[63:32] +1; //ticket+1 write_rank_data_next[95:64] =

(53)

same

n_state = add_rank_state;

add_rank = 1;

end else begin

n_state = r_rank;

end end

add_rank_state: //2 begin

if (rdy_rank == 1) begin

n_state = decide_RK;

end end

decide_RK://3 begin

if

(read_rank_data[63:32]-read_rank_data[95 :64] > 6)

begin

write_change_data_next[95:0] = read_rank_data[95:0];

n_state = add_change_state;

add_change = 1;

end else begin

n_state = idle;

end end

r_rank: //4 begin begin

ip_rank_out_next[31:0] = ip[31:0];

lookup_rank = 1;

rank_n = rank_in;

end begin

if (rdy_rank == 1) if (found_rank == 1) begin

else begin

write_change_data_next[95:0] = read_rank_data[95:0];

n_state = decide_K;

end end end

decide_K: //5 begin

if

(read_rank_data[63:32]-read_rank_data[95 :64] >6)

begin

n_state = add_change_state;

add_change = 1;

end else begin

n_state = idle;

end end

add_change_state: //6 begin

if (rdy_change == 1) begin

n_state = idle;

end end endcase end

always @(posedge clk, negedge reset) if (reset == 0)

begin

p_state <= idle;

write_change_data <= 0;

write_rank_data <= 0;

ip_change_out <= 0;

ip_rank_out <= 0;

rdy_control <= 0;

end else

(54)

write_change_data <=

write_change_data_next;

ip_change_out <= ip_change_out_next;

ip_rank_out <= ip_rank_out_next;

rdy_control <= rdy_control_next;

end

endmodule

module

changetb(clk,reset,add_change,lookup_cha

nge,write_change_data,rdy_change, read_change_data,found_change,addra,cha nge_tb_in,ip,

change_tb_out,wea,ena);

input

clk,reset,add_change,lookup_change;

input [31:0] ip;

input [95:0] write_change_data;

input [95:0] change_tb_in; //ip [31:0]

//ticket[63:32]

//cb [95:64]

output reg

rdy_change,found_change,wea,ena;

output wire [3:0] addra;

output reg [95:0] read_change_data;

output reg [95:0] change_tb_out; //ip [31:0]

//ticket[63:32]

//cb [95:64]

localparam idle = 0;

localparam read_tbd = 1;

localparam write_de = 2;

localparam read_tba = 3;

localparam write_tb = 4;

reg found_change_next;

reg [2:0] p_state,n_state;

reg [15:0]

k1,k2,k3,k4,k5,k1_next,k2_next,k3_next,k 4_next,k5_next;

reg [2:0] addr_cnt,addr_cnt_next;

reg [95:0]

top1,top1_next,top2,top2_next,top3,top3_n ext,top4,top4_next,top5,top5_next;

reg [95:0] read_change_data_next;

reg [31:0] ip_reg,ip_next;

wire [15:0] add_k =

write_change_data[63:32] - write_change_data[95:64];

always @*

begin

rdy_change = 0;

wea = 0;

ena = 1;

found_change_next = found_change;

n_state = p_state;

addr_cnt_next = addr_cnt;

read_change_data_next = read_change_data;

ip_next = ip_reg;

change_tb_out = 0;

k1_next = k1;

k2_next = k2;

k3_next = k3;

k4_next = k4;

k5_next = k5;

top1_next = top1;

top2_next = top2;

top3_next = top3;

top4_next = top4;

top5_next = top5;

case(p_state) idle:

if (lookup_change == 1) begin

ip_next = ip;

n_state = read_tbd;

end

else if (add_change == 1) n_state = read_tba;

read_tbd:

begin begin ena = 1;

wea = 0;

ip_next = ip;

end

if (addr_cnt == 1) begin

begin

top1_next[95:0] = change_tb_in[95:0];

end

if (ip_reg == top1_next[31:0])

(55)

read_change_data_next[95:0] = top1_next[95:0];

found_change_next = 1;

n_state = read_tbd;

end end

else if (addr_cnt == 2) begin

begin

end

if (ip_reg == top2_next[31:0]) begin

n_state = read_tbd;

end end

begin

end

n_state = read_tbd;

end end

begin

end

n_state = read_tbd;

end end

n_state = read_tbd;

end end

if (found_change == 1) begin

n_state = write_de;

end else begin

n_state = idle;

rdy_change = 1;

end end end write_de:

if (ip_reg == top1[31:0]) //lookup top1 begin

wea = 1;

change_tb_out[95:0] = top2[95:0];

end

wea = 1;

end

wea = 1;

end

wea = 1;

end

else if (addr_cnt == 4)

(56)

rdy_change = 1;

n_state = idle;

end end

else if (ip_reg == top2[31:0])//lookup top2 begin

wea = 1;

end

wea = 1;

end

wea = 1;

end

wea = 1;

end

wea = 1;

change_tb_out[95:0] = 96'b0;

rdy_change = 1;

n_state = idle;

end end

wea = 1;

end

wea = 1;

end

else if (addr_cnt == 2)

wea = 1;

end

wea = 1;

end

wea = 1;

rdy_change = 1;

n_state = idle;

end end

wea = 1;

end

wea = 1;

end

wea = 1;

end

wea = 1;

end

wea = 1;

rdy_change = 1;

n_state = idle;

end end

else if (ip_reg == top5[31:0])//lookup top5

中 華 大 學

中 華 大 學 碩 士 論 文

找出網路串流中最頻繁的項目及其電路實做 Finding Heavy-Hitter from Network Streams and

Its Hardware Implementation

系 所 別：電機工程學系碩士班 學號姓名：M09701018 吳延鵬 指導教授： 謝坤融 博士

高曜煌 博士

摘 要

ABSTRACT

Keywords: network streams、Heavy-Hitter、frequent items、network traffic

誌謝

目錄

Abstract ... ii

iv

vi

vii

1

3

8

40

41

43

表目錄

圖目錄

第一章 緒論

1.1 研究背景

1.2 研究動機與目的

1.3 論文章節概述

第二章 文獻回顧

2.1 Majority 演算法

2.2

Freq

B 1 A

quent 演

B 2 B

演算法

B 1 B

A

0 T

A

1 F

A

2 A

A 項

1 票

A

項目

票數

2.3 Space-Saving 演算法

A

A

B

B

C

C

A

A

B

B

C

K

B

K

2.4 Sketch 演算法

3.1

使用演

演算法

第三章

章 研

研究方法

法

3.2 改進方法與優點

3.2.1 Change Table

3.2.2 真實票數（K）

K = Votes – CB

3.3 模擬分析

3.4 硬體實現

3.4.1 完整 Block

3.4.2 主要控制電路（Main Control）

Main Control

Rank Table

中華大學

中華大學碩士論文

系所別：電機工程學系碩士班學號姓名：M09701018 吳延鵬指導教授：謝坤融博士

高曜煌博士

摘要

第一章緒論

第二章文獻回顧

章研

第四章結論

附錄電路程式碼