2013 IEEE Conference on Open Systems (ICOS), December 2 - 4, 2013, Sarawak, Malaysia

A Parallel Bloom Filter String Searching Algorithm

on a Many-core Processor
WenMei Ong, Vishnu Monn Baskaran
Faculty of Engineering,
Multimedia University,
Cyberjaya campus, Selangor, Malaysia.
wenmei15@gmail.com,
vishnu.monn@mmu.edu.my
Poh Kit Chong Ettikan K. K, Keh Kok Y ong
Accelerative Technology Lab,
MIMOS Berhad,
Faculty of Engineering and Science,
University Tunku Abdul Rahman,
Petaling Jaya, Selangor, Malaysia.
pkchong@utar.edu.my
Kuala Lumpur, Malaysia.
ettikan.karuppiah@mimos.my
kk.yong@mimos.my

Abstract - This paper analyzes the underlying architecture of a

serial Bloom filter string searching algorithm to identify the
performance impact of this algorithm for large datasets. Then,a
parallel multi-core driven Bloom filter algorithm using software
application threads is studied as benchmark. Experimental
results suggest that for a set of 10 million strings,this algorithm
exhibits speedups of up to 3.3x against a serial Bloom filter
algorithm, when using an 8-logical processor multi-core
architecture. To further improve the speedup, a many-core
driven parallel Bloom filter algorithm is proposed using the
Compute Unified Device Architecture (CUDA) parallel
computing platform. The proposed algorithm segments the string
list into blocks of words and threads in generating the bit table
for the string searching process,which maximizes computational
performance and sustains consistent string searching results.
Experimental results suggest that the proposed algorithm extends
the speedup to S.SX against a serial Bloom filter algorithm,when
using a 2S6-core CUDA graphics processing unit architecture.
Keywords - Bloom filter,string searching,parallel computing,
CUDA,GPGPU
Abstrak - tulisan ini menganalisa arsitektur yang mendasari
serial mekar string penyaring pencarian algoritma untuk mengidentifikasi
mempengaruhi kinerja algoritma ini untuk dataset besar. Kemudian,
paralel multi-core didorong Bloom penyaring algoritma menggunakan perangkat
lunak
aplikasi benang dipelajari sebagai patokan. Eksperimental
hasil menunjukkan bahwa untuk satu set 10 juta string, algoritma ini
Pameran speedups hingga 3.3 x terhadap serial Bloom penyaring
algoritma, ketika menggunakan 8-Logis prosesor multi-core
arsitektur. Untuk lebih meningkatkan speedup, banyak-core
didorong paralel Bloom penyaring algoritma yang diusulkan menggunakan
Menghitung paralel Unified Device arsitektur (CUDA)
platform komputasi. Algoritma yang diusulkan segmen string
Daftar menjadi blok-blok kata-kata dan benang menghasilkan tabelbit
untuk string pencarian proses, yang memaksimalkan komputasi
kinerja dan menopang konsisten string hasil pencarian.
Hasil percobaan menunjukkan bahwa algoritma yang diusulkan meluas
speedup untuk S.SX terhadap serial Bloom penyaring algoritma, ketika
menggunakan grafis CUDA 2S6-core pengolahan unit arsitektur.
Kata kunci - mekar filter, string pencarian, paralel komputasi,
CUDA, GPGPU

I. INTRODUCTION
String searching algorithms represent a fundamental
method of finding an element or a set of elements with
specific properties among a collection of elements. Since the
advent of the computing and digital storage technology, the
capacity of storing substantial amount of data, from which
individual records are to be retrieved, identified or located
have paved the way in the design and development of various
string searching algorithms.
Rudimentary linear based string searching algorithms were
initially applied due to its simplicity in design at the expense
of poor searching performance for large datasets. Binary string
searching algorithms substantially improved searching
performance, albeit requiring the dataset to be sorted, which
impacts its overall efficiency [\]. Hash tables were later
introduced using associative arrays to map as a structure to
maps keys to data set values, which prove to be a good choice
when the keys are sparsely distributed [2]. It is also chosen
when the primary concern is the speed of access to the data.
However, sufficient memory is needed to store the hash table.
This lead to limitations in the datasets as a larger hash table is
required to cater for a larger dataset.
978-1-4799-0285-9/13/$31.00 2013 IEEE
One approach to address the limitations of the hash table
would be the utilization of the Bloom filter string searching
algorithm as a memory-efficient data structure, which rapidly
indicates whether an element is present in a dataset [3]. In
spite of improved speed and efficiency, a serial Bloom filter
design, which runs on a single logical processor, would still
incur longer processing time for substantial increases in
dataset size.
The advancement of computing technology has seen
significant developments of the multi-core processing
technology in line with the progression of parallel computing
solutions. This in turn has also fueled the development of the
many-core processing technology, such as the incorporation of
generic stream processing units into a Graphics Processing
Unit (GPU), allowing generalized computing devices with
large numbers of processing cores and hence the term, General
purpose computing on GPU (GPGPU). The deployment of the
Compute Unified Device Architecture (CUDA) parallel
computing platform by NVIDIA for GPGPUs has further
increased adaptation of parallel computing solutions using a
many-core architecture. A GPU offers high performance
throughput with little overhead between the threads. By
performing uniform operations on independent data, massive
data parallelism in an application can be achieved.
However, a serial Bloom filter algorithm would not be able
to leverage on the advancements of both the multi-core and
many-core architectures for improved searching performance
for large datasets. Hence, this paper investigates the impact of
a serial Bloom filter algorithm for large datasets, in justifying
the need for a parallel architecture in accelerating the string
searching process. In achieving an effective parallel string
searching design, a parallel Bloom filter algorithm using
software application threads for a multi-core architecture is
first investigated as a benchmark, which exhibits improved
performance speedups against a serial Bloom filter. In further
improving the speedup, a parallel Bloom filter algorithm using
the CUDA parallel computing platform is proposed, to support
batch-oriented string search operation in a data-intensive high
performance system. The proposed algorithm segments the
string list into blocks of words and threads in generating the
bit table, which is used during the string searching process.
This method maximizes the computational performance and
sustains consistent string searching results.
2013 IEEE Conference on Open Systems (ICOS), December 2 - 4, 2013, Sarawak, Malaysia
An eXlstmg CUDA implementation of the Bloom filter
string searching algorithm by Costa et al. [4] limits the false
positive probability (fpp) to 10-4 and the number of strings
tested for both the insertion and searching processes to 1
million. In this paper however, the proposed parallel Bloom
filter algorithm using CUDA removes the limit on fpp, and
instead, computes the fpp based on the number of strings
involved in the insertion process. In addition, the number of
strings tested is increased to 10 million for a more accurate
representation in performance speedup assessment.
The paper is organized as follows. Section II investigates
the performance impact of a serial Bloom filter string
searching algorithm. Section III describes the parallel Bloom
filter algorithm on a multi-core architecture. Section IV
proposes the parallel Bloom filter algorithm using the CUDA
parallel computing platform on many-core architecture.
Section V concludes this paper.
I. PENDAHULUAN
Algoritma pencarian string mewakili yang mendasar
metode menemukan elemen atau serangkaian elemen dengan
properti tertentu antara kumpulan elemen. Karena
kedatangan dari komputasi dan digital teknologi penyimpanan,
kapasitas menyimpan sejumlah besar data, yang
setiap catatan yang diperoleh, diidentifikasi atau terletak
telah membuka jalan dalam desain dan pengembangan berbagai
string pencarian algoritma.
Dasar linier berbasis string pencarian algoritma yang
pada
awalnya diterapkan karena kesederhanaan dalam desain dengan mengorbankan
miskin kinerja pencarian untuk dataset besar. Rangkaian biner
mencari algoritma pencarian ditingkatkan secara substansial
kinerja, walaupun memerlukan dataset harus disortir, yang
dampak keseluruhan efisiensi [\]. Tabel hash kemudiannya
memperkenalkan menggunakan array asosiatif untuk memetakan sebagai struktu
r untuk
peta kunci untuk nilai-nilai data set, yang terbukti menjadi pilihan yang baik
Ketika tombol yang jarang didistribusikan [2]. Itu juga dipilih
Ketika perhatian utama adalah kecepatan akses ke data.
Namun, cukup memori diperlukan untuk menyimpan Tabel hash.
Hal ini menyebabkan keterbatasan dalam dataset sebagai Tabel hash besar adala
h
diperlukan untuk memenuhi dataset besar.
978-1-4799-0285-9/13/$31.00 2013 IEEE
Salah satu pendekatan untuk mengatasi keterbatasan hash table
akan menjadi penggunaan Bloom penyaring string pencarian
algoritma sebagai hemat memori data struktur, yang cepat
menunjukkan apakah elemen hadir dalam dataset [3]. Dalam
Meskipun meningkatkan kecepatan dan efisiensi, serial Bloom penyaring
Desain, yang berjalan pada prosesor logis tunggal, masih
dikenakan waktu pengolahan lebih lama untuk peningkatan substansial dalam
ukuran dataset.
Kemajuan teknologi komputasi telah melihat
perkembangan yang signifikan dari proses multi-core
Technology sejalan dengan perkembangan komputasi paralel
solusi. Ini pada gilirannya telah juga memicu pengembangan
banyak-core pengolahan teknologi, seperti penggabungan
generik stream unit pengolahan ke pengolahan grafis
Unit (GPU), memungkinkan perangkat komputasi yang umum dengan
sejumlah besar Core pengolahan dan karenanya istilah, Umum
tujuan komputasi pada GPU (GPGPU).
Penyebaran
Menghitung paralel Unified Device arsitektur (CUDA)
memiliki platform komputasi oleh NVIDIA untuk GPGPUs lebih lanjut
peningkatan adaptasi paralel komputasi solusi menggunakan
banyak-core arsitektur. GPU menawarkan kinerja tinggi
throughput dengan sedikit overhead antara benang. Oleh
melakukan seragam operasi pada data independen, besar-besaran
data paralelisme dalam aplikasi dapat dicapai.
Namun, sebuah serial Bloom penyaring algoritma tidak akan dapat
untuk memanfaatkan kemajuan kedua multi inti dan
arsitektur banyak-inti untuk meningkatkan kinerja pencarian
untuk dataset besar. Oleh karena itu, makalah ini menyelidiki dampak
serial Bloom penyaring algoritma untuk dataset besar, dalam membenarkan
kebutuhan untuk arsitektur yang paralel dalam mempercepat string
proses pencarian. Dalam mencapai string paralel yang efektif
mencari desain, paralel Bloom penyaring algoritma menggunakan
threads aplikasi perangkat lunak untuk arsitektur multi-core adalah
pertama diselidiki sebagai patokan, yang menunjukkan peningkatan
kinerja speedups terhadap serial Bloom penyaring. Pada lebih lanjut
meningkatkan speedup, Bloom paralel filter menggunakan algoritma
platform komputasi paralel CUDA yang diusulkan, untuk mendukung
string berorientasi batch operasi pencarian yang tinggi data-intensif
kinerja sistem. Algoritma yang diusulkan segmen
Daftar string ke dalam blok kata-kata dan benang menghasilkan
bit tabel, yang digunakan selama string pencarian proses.
Metode ini memaksimalkan kinerja komputasi dan
menopang konsisten string hasil pencarian.
2013 IEEE konferensi Open System (ICOS), 2-4 Januari 2013, Sarawak, Malaysia
CUDA eXlstmg pelaksanaan Bloom penyaring
algoritma pencarian string oleh Costa et al. [4] batas palsu
positif probabilitas (fpp) untuk 10-4 dan jumlah string
diuji untuk penyisipan dan proses pencarian untuk 1
juta. Dalam tulisan ini namun, paralel diusulkan mekar
algoritma filter menggunakan CUDA menghapus batas fpp, dan
Sebaliknya, menghitung fpp berdasarkan jumlah string
terlibat dalam proses penyisipan. Selain itu, jumlah
string yang diuji meningkat menjadi 10 juta untuk lebih akurat
Perwakilan dalam penilaian speedup kinerja.
Karya ini disusun sebagai berikut. Menyelidiki Bagian II
dampak kinerja serial mekar saringan
algoritma pencarian. Bagian III menjelaskan mekar paralel
Filter algoritma arsitektur multi-core. Bagian IV
mengusulkan mekar paralel menggunakan CUDA algoritma filter
platform komputasi paralel pada banyak-core arsitektur.
Bagian V menyimpulkan karya ini.

II. PERFORMANCE IMPACT OF A SERIAL BLOOM

FIL TER SEARCHING ALGORITHM
A. The Bloom Filter String Searching Algorithm
The Bloom filter data structure is defined as a set of M bit
table array, with m =1 M 1 and all array elements initially set
to 0. Note that k different hash functions are defined; each will
map or hash the set elements to one of the M array positions
[5]. The hash functions must give uniform random distributed
results, such that the array can be filled up uniformly and
randomly [6].
To add or insert an element into the filter for a set of
strings, N with n =1 N I, the element is first passed to every k
hash function to generate k indices of a Bloom filter array. The
corresponding bits in the array are then set to 1. To check for
the presence of an element in the set, or query for it, the
element is passed to every hash function to get indices of the
array. In the event any of the bits at these array positions is
found to be 0, then the element is confirmed as not in the set.
If all of the bits at these positions are set to 1, then either the
element is indeed present in the set, or the bits have been set to
1 by chance when other elements are inserted, hence causing a
false positive [7].
Assuming that the hash functions used are independent
and uniformly distributed, the array position will be selected
with equal probability. The probability of a bit not set to 1
after inserting n string elements into a filter array of size m bits
using k hash functions is [4][8]:
PnOlsel = (l-l/m)kn (I)
When a false positive occurs, all the corresponding bits in
the array are found to be I; the algorithm erroneously claims
that the element is in the set. Hence, the false positive
probability ifpp) of all corresponding bits of an element being
set to 1 after inserting n elements into a filter array of size m
bits using k hash functions is given as [4]:
2
From Eq. (2), as m decreases:
(3)
and as n increases:
(4)
Equations (3) and (4) show that thefpp increases when m
decreases or when n increases, respectively. A large dataset
indicates a large n value. To minimize the fpp, m would need
to be set to a large value (i.e., using a large Bloom filter),
which in turn increases the requirements of memory capacity.
Trade-off betweenjpp and memory space is thus required.
B. Implementation and Performance Assessment
A serial implementation of the Bloom filter string
searching algorithm was developed using Visual C++ as a
complete software application. The computing hardware
specifications were configured by utilizing an Intel Core i7-
2700K processor at 3.50 GHz operating frequency, with 8-
logical processors and 8GBytes of system memory. The fpp is
initially set to lin with k = 500 and m is computed such that:
m = -kn / log(l- jpp(lIk)) (5)
The implementation of the serial Bloom filter consist of
the insertion and searching processes as illustrated in Fig. lea)
and Fig. 1(b) respectively in line with a custom hash algorithm
(i.e., APHash) developed by Partow [9]. The APHash
algorithm is based on a hybrid rotative and additive hash
function implementation, with an aim to produce the least
amount of collisions for a set of data. To obtain several hash
functions from the same hash algorithm, an array termed
sal t is utilized, whereby each element represents an initial
hash value. As illustrated in Fig. 1 (a), to insert a string into
the filter, hash functions are performed on the string and the
corresponding bits are set. All strings in the input word file are
inserted sequentially. Fig. l(b) shows the algorithm for
searching the filter. To check the existence of each query, the
same hash functions are performed on the query and the
corresponding bits of the Bloom filter are checked. If any of
the bits is not set, the query does not exist in the filter.
An experiment was carried out to analyze the performance
of the serial Bloom filter algorithm by varying the value of n,
between 1000 and 10,000,000 strings. The length of each
string in the word-list and query-list is fixed not to exceed 20
characters. A set of 500 hashes (i.e., k = 500) are performed on
each string. Both the filter insertion and searching processes
are executed and repeated for five consecutive runs, in which
an average operation time is then recorded.
Fig. 2 illustrates the average total process time of both the
serial filter insertion and searching processes for an increasing
value of n. Results from Fig. 2 suggest that as n increases, an
increase in the processing time for the serial Bloom filter
algorithm is observed. The required processing time reached a
high of 360 seconds for n = 10,000,000. In addition, CPU
2013 IEEE Conference on Open Systems (ICOS), December 2 - 4, 2013, Sarawak, Malaysia
utilization registered a 12.5% usage, constituting a meager
l/Sth usage of the available logical processors, which is in line
with serial behavior of this algorithm.
kf- number of hash functions.
II. KINERJA DAMPAK MEKAR SERIAL
ALGORITMA PENCARIAN FIL TER
A. mekar Filter String pencarian algoritma
Struktur data Bloom penyaring didefinisikan sebagai satu set M bit
Meja array, dengan m = 1 M 1 dan semua elemen array awalnya diatur
ke 0. Perhatikan bahwa fungsi hash berbeda k ditentukan; masing-masing akan
peta atau hash posisi elemen set untuk salah satu M array
[5]. fungsi hash harus memberikan seragam acak didistribusikan
hasil, sehingga array dapat diisi seragam dan
secara acak [6].
Untuk menambahkan atau masukkan elemen ke filter untuk satu set
string, N dengan n = 1 N I, unsur pertama ditularkan ke setiap k
fungsi hash untuk menghasilkan k indeks array filter mekar. The
potongan-potongan yang sesuai dalam array kemudian diatur ke 1.Untuk memerik
sa
kehadiran elemen di set, atau permintaan untuk itu,
elemen dilewatkan ke setiap fungsi hash untuk mendapatkan indeksdari
array. Dalam hal salah satu bit di posisi array ini adalah
ditemukan untuk menjadi 0, kemudian elemen dikonfirmasi sebagaitidak di set.
Jika semua bit di posisi ini diatur ke 1, maka baik
elemen memang ada di set, atau bit yang telah ditetapkan
1 secara kebetulan ketika unsur-unsur lain yang dimasukkan, makamenyebabkan
positif palsu [7].
Dengan asumsi bahwa fungsi hash yang digunakan independen
dan merata, posisi array akan dipilih
dengan kemungkinan yang sama pentingnya. Kemungkinan agak tidak diatur ke 1
Setelah memasukkan unsur-unsur n string ke dalam array filter ukuran m bit
menggunakan fungsi hash k adalah [4] [8]:
PnOlsel = kn (l-l/m) (I)
Ketika positif palsu terjadi, semua bit sesuai di
array ditemukan saya; algoritma keliru klaim
elemen yang di set. Oleh karena itu, positif palsu
probabilitas ifpp) semua bit sesuai elemen yang
diatur ke 1 setelah memasukkan unsur-unsur n ke dalam array filterukuran m
bit menggunakan fungsi hash k diberikan sebagai [4]:
2
Dari EQ (2), sebagai m menurun:
(3)
dan sebagai n meningkatkan:
(4)
Persamaan (3) dan (4) menunjukkan bahwa thefpp meningkat ketikam
berkurang atau Kapan n meningkat, masing-masing. Dataset besar
menunjukkan nilai n besar. Untuk meminimalkan fpp, m akan perlu
harus ditetapkan ke nilai besar (yaitu, menggunakan filter mekar besar),
yang pada gilirannya akan meningkatkan kebutuhan kapasitas memori.
Ruang betweenjpp dan memori trade-of dengan demikian diperlukan.
B. pelaksanaan dan penilaian kinerja
Serial pelaksanaan dengan string penyaring mekar
mencari algoritma dikembangkan dengan menggunakan Visual C++sebagai
lengkap aplikasi perangkat lunak. Hardware komputasi
spesifikasi yang dikonfigurasi dengan memanfaatkan Intel Core i7-
2700K prosesor pada 3.50 GHz operasi frekuensi, dengan 8-
prosesor logis dan 8GBytes sistem memori. FPP
pada awalnya diatur untuk lin dengan k = 500 dan m dihitung sedemikian
rupa sehingga:
m = -kn / log (l-jpp(lIk)) (5)
Pelaksanaan serial Bloom penyaring terdiri dari
penyisipan dan proses pencarian sebagai diilustrasikan pada gambar. Lea)
dan gambar 1(b) masing-masing sesuai dengan algoritma hash kustom
(yaitu APHash) dikembangkan oleh Partow [9]. APHash
algoritma didasarkan pada hash rotative dan aditif hibrida
implementasi fungsi, dengan tujuan untuk menghasilkan setidaknya
jumlah tabrakan untuk satu set data. Untuk mendapatkan beberapahash
fungsi dari algoritma hash yang sama, array disebut
Sal t yang digunakan, dimana setiap elemen mewakili awal
nilai hash. Sebagai diilustrasikan dalam 1 GB (a), untuk memasukkanstring ke
filter, hash fungsi dilakukan pada string yang
sesuai bit ditetapkan. Semua string dalam file masukan kata
dimasukkan secara berurutan. L(b) gambar menunjukkan adanya algoritma untuk
pencarian filter. Untuk memeriksa keberadaan setiap pertanyaan,
fungsi hash yang sama dilakukan pada query dan
potongan-potongan yang sesuai filter mekar diperiksa. Jika salah satu
bit tidak diatur, query tidak ada di dalam filter.
Percobaan dilakukan untuk menganalisis kinerja
dari serial Bloom penyaring algoritma dengan memvariasikan nilain,
antara 1000 dan 10.000.000 string. Panjang setiap
string dan kata-daftar permintaan-daftar tetap tidak melebihi 20
karakter. Satu set 500 hash (yaitu, k = 500) dilakukan pada setiap string. Kedua
penyisipan filter dan menelusuri proses

dijalankan dan diulang untuk berjalan berturut-turut lima, di mana

waktu rata-rata operasi kemudian dicatat.
Gambar 2 menggambarkan proses total rata-rata waktu kedua
serial filter penyisipan dan menelusuri proses untuk meningkatkan
nilai n. hasil dari Fig. 2 menunjukkan bahwa sebagai n meningkat,
meningkatkan waktu pemrosesan untuk filter mekar serial
algoritma yang diamati. Mencapai waktu pemrosesan yang diperlukan
tinggi 360 detik untuk n = 10,000,000. Selain itu, CPU
2013 IEEE konferensi Open System (ICOS), 2-4 Januari 2013, Sarawak, Malaysia
pemanfaatan terdaftar penggunaan 12.5%, yang merupakan sedikit
l Sth penggunaan prosesor logis yang tersedia, yang sejalan
dengan serial perilaku dari algoritma ini.
KF-jumlah fungsi hash.

M filter data table array.

mf-I Mil
bit_maskf- masking array (8
elements) for collision
avoidance.
wJf- j-th word of N ,
j=0,1.2,... N-I
(b)
Figure 1. Bloom filter insertion (a) and searching (b) process for one word [9].
400,000
320,000 C=-
280,000
g 240,000
"
F 200,000
E 00
00 160,000
8
2 120,000
"-
80,000
40.000
1.00E+03 1.00E+04 1.00E+05
Number ofs1rings, n
1.00E+06 1.00E+07
Figure 2. Performance assessment of a serial implementation of the Bloom
filter algorithm (inserts and search) for an increasing n.
As n increases by 1, the total number of hash functions to
be performed increases by a factor of k, which in turn
increases the computational load. Tn order to reduce the
execution time of the algorithm, a more time-efficient
programming paradigm is needed. The repetitive process of
performing hash functions on different strings suggests that
parallelization may be applied. Bernstein's Conditions were
examined and have proven that the data has no dependency on
each other, confirming that the hashing algorithm for different
strings can be executed concurrently. The following section
discusses the implementation of a parallel Bloom filter
algorithm on a multicore processor.

Penilaian kinerja pelaksanaan serial mekar

Filter algoritma (menyisipkan dan Cari) untuk n meningkat.
Sebagai n meningkat oleh 1, jumlah hash berfungsi
akan meningkatkan dilakukan oleh faktor k, yang pada gilirannya
meningkatkan beban komputasi. Tn agar mengurangi
waktu pelaksanaan dari algoritma, lebih hemat waktu
paradigma pemrograman diperlukan. Proses berulang-ulang
melakukan fungsi hash string yang berbeda menunjukkan bahwa
parallelization dapat diterapkan. Kondisi di Bernstein
memeriksa dan telah terbukti bahwa data telah tidak ada ketergantungan pada
satu sama lain, mengkonfirmasikan bahwa hashing algoritma untuk berbeda
string dapat dijalankan secara bersamaan. Bagian berikut
membahas pelaksanaan paralel Bloom penyaring
algoritma pada prosesor multicore.

III. PARALLEL BLOOM FILTER ON A MULTICORE

ARCHITECTURE
To address the performance impact of the serial Bloom
filter algorithm for a large n, a parallel multi-core driven
Bloom filter algorithm is implemented here using the OpenMP
application programming interface. The program flow for this
parallel algorithm is generally similar to the serial Bloom filter
algorithm, with the exception on the workload distribution for
the insertion and searching processes. Both these processes
involve performing similar set of tasks on different datasets,
providing an opportunity for data parallelism.
Fig. 3 illustrates the execution model of the parallel Bloom
filter insertion process using OpenMP. Here, a set of software
application threaOds, 'IT' are created to concurrently execute the
insertion process based on a n! I 'IT'I workload distribution.
I 'IT' I equals the number of available logical processors on a
multicore architecture. An atomic operation is applied when
updating the bit-table array, M to minimize simultaneous
writes on the same M array location pointed by different
application threads.
kf- number of hash functions.
Mf- filter data table array.

III. PARALEL MEKAR FILTER DI MULTICORE

ARSITEKTUR
Untuk mengatasi dampak kinerja mekar serial
Filter algoritma untuk n besar, multi-core paralel didorong
Bloom penyaring algoritma yang diimplementasikan di sini menggunakan OpenMP
antarmuka pemrograman aplikasi. Aliran program ini
paralel algoritma ini umumnya mirip dengan serial Bloom penyaring
algoritma, dengan pengecualian pada distribusi beban kerja untuk
penyisipan dan proses pencarian. Kedua proses ini
melibatkan melakukan set sama tugas pada dataset yang berbeda,
memberikan kesempatan bagi paralelisme data.
Fig. 3 menggambarkan model eksekusi mekar paralel
menyaring penyisipan proses menggunakan OpenMP. Di sini, satu set perangkat lunak
aplikasi threaOds, 'Itu' yang diciptakan untuk dijalankan secara bersamaan
penyisipan proses berdasarkan n! Aku ' IT'I beban kerja distribusi.
Saya 'IT' saya sama dengan jumlah prosesor logis yang tersedia pada
arsitektur multicore. Operasi atomik diterapkan ketika
memperbarui sedikit-table array, M untuk meminimalkan simultan
menulis pada lokasi yang sama M array ditunjuk oleh berbeda
benang aplikasi.
KF-jumlah fungsi hash.
MF-filter data tabel array.

mMlI
bit maskf- masking array (8
- elements).
'II' f- set of application threads
tpf- p-th thread of ']I' ,
,=0,1,2,... 1l"-1
MI[biUndex/B] 1=
bit_mask[bit] biCmask[bit]
Figure 3. Parallel Bloom filter insertion on a multicore architecture.
Fig. 4 illustrates the execution model of the parallel Bloom
filter searching process using OpenMP. The algorithm for the
parallel Bloom filter searching algorithm in Figure 5 adopts a
similar implementation to that of the serial Bloom filter
searching as discussed in the aforementioned section. The
atomic operation as applied in the insertion process is not
required here as the application threads are only reading the bit
table, M value from memory, thus leaving the M memory
content unchanged. Similar to the parallel filter insertion
process, 'IT' application threads concurrently execute the
searching process based on a n! I 'IT'I workload distribution,
with results of the search operation being stored in memory.
2013 IEEE Conference on Open Systems (ICOS), December 2 - 4, 2013, Sarawak, Malaysia
kf. number of hash functions.
M f. filter data table array.
mf-I Mil
bit_rnaskf- masking array (8
elements) for collision
avoidance.

Gambar 3. Paralel Bloom penyaring penyisipan pada arsitektur multicore.

Gambar 4 menggambarkan model eksekusi mekar paralel
Menyaring pencarian proses menggunakan OpenMP. Algoritma untuk
mengadopsi paralel Bloom penyaring pencarian algoritma pada gambar 5
pelaksanaan serupa dengan serial Bloom penyaring
mencari sebagai dibahas dalam bagian tersebut. The
Atom operasi seperti yang diterapkan dalam proses penyisipan ini tidak
diperlukan di sini sebagai benang aplikasi hanya membaca sedikit
Biliar, M nilai dari memori, sehingga meninggalkan memori M
konten tidak berubah. Mirip dengan penyisipan paralel filter
proses, 'Itu' aplikasi benang merangkap mengeksekusi
proses pencarian berdasarkan n! Aku ' IT'I beban kerja distribusi,
dengan hasil operasi pencarian akan disimpan dalam memori.
2013 IEEE konferensi Open System (ICOS), 2-4 Januari 2013, Sarawak, Malaysia
KF. jumlah fungsi hash.
M f. filter data tabel array.
MF-saya Mil
bit_rnaskf-masking array (8
unsur-unsur) untuk tabrakan
penghindaran.

t., f- p.th thread of'][' ,

=0.1.2... 1r -I
Figure 4. Parallel Bloom filter searching on a multicore architecture.
400,000
360,000
320,000
'00' 280,000
..s 240,000
. 200,000
E 160,000
2 120,000
P-
80,000
40,000
=
----+-- ----+--
ffi ---*- ---+- --e-- Parallel Performance Serial Bloom Bloom Speedup filter filter using OpenMP
t=
3.60
3.40
3.20
J;
7' 3.00
2.80
2.60
2.40
2.20
2.00
1.80
-=== '*' -===
1.00E+03 1.00E+04 1.00E+05 1.00E+06
Number of strings, 11
1.60
1.00E+07
g.
]
c.
rn
"
u
iii
E

"-
Figure 5. Performance analysis of a parallel Bloom filter algorithm on a
multicore architecture against a serial Bloom filter for an increasing n.
Replicating the test setup in Section 2, a performance
analysis was carried out to evaluate the effectiveness of the
multi-core parallel Bloom filter algorithm, in comparison with
the serial Bloom filter algorithm. Fig. 5 illustrates the average
operation time (i.e., for both insertion and searching) of the
parallel Bloom filter algorithm implemented using OpenMP
with 1'][' 1= 8 in comparison with the serial Bloom filter
algorithm. In addition, Fig. 5 also computes the performance
speedup to analyze the scale of operation time improvement of
the multi-core parallel Bloom filter algorithm against the serial
Bloom filter algorithm (green circle). Results from Fig. 5
suggest marked speedups of the multi-core parallel Bloom
filter algorithm against the serial Bloom filter algorithm. A
notable improvement in computational performance is visible
for n = 10,000,000 with the multi-core parallel algorithm
registering a 109 second computational time against a 360
second computational time by the serial algorithm, which in
tum yields a 3.3x in performance speedup. In addition, a steep
increase in performance speedup is initially observed as n
4
increases from 1000 to 100,000 strings, which then exhibits a
consistent speedup as n > 500,000 strings. The consistent
speedup as n > 500,000 is deduced as a result of logical
processor (i.e., 1'][' 1= 8) saturation in processing the large
values of n. Further speedups are attainable if 1'][' 1 increases
for an increase in the number of available logical processors.
This puts forward the concept of leveraging on the many-core
compute capabilities of a GPU processor for general purpose
computing, which will explored in the following section.

Gambar 5. Analisis kinerja Bloom penyaring algoritma paralel pada

arsitektur multicore terhadap serial Bloom penyaring untuk n meningkat.
Replikasi setup tes di bagian 2, kinerja
Analisis dilakukan untuk mengevaluasi efektivitas
multi-core paralel Bloom penyaring algoritma, dibandingkan dengan
serial Bloom penyaring algoritma. Gambar 5 mengilustrasikan rata-rata
waktu operasi (yaitu, baik untuk penyisipan dan mencari)
paralel algoritma Bloom penyaring diimplementasikan menggunakan OpenMP
dengan 1'] [' 1 = 8 dibandingkan dengan serial Bloom penyaring
algoritma. Selain itu, Gambar 5 juga menghitung kinerja
speedup untuk menganalisis skala waktu operasi perbaikan
multi-core paralel Bloom penyaring algoritma terhadap serial
Bloom penyaring algoritma (lingkaran hijau). Hasil dari gambar 5
speedups ditandai multi-core paralel mekar menyarankan
Filter algoritma terhadap serial Bloom penyaring algoritma. A
penting perbaikan dalam kinerja komputasi terlihat
untuk n = 10,000,000 dengan multi-core paralel algoritma
mendaftar waktu komputasi 109 kedua melawan 360
kedua komputasi waktu oleh algoritma serial, yang dalam
Tum menghasilkan x 3.3 dalam kinerja speedup. Selain itu, curam
peningkatan kinerja speedup awalnya diamati sebagai n
4
meningkat dari 1000 menjadi 100.000 string, yang kemudian pameran
konsisten speedup sebagai string n > 500.000. Yang konsisten
speedup sebagai n > 500.000 disimpulkan sebagai hasil dari Logis
prosesor (yaitu 1'] [' 1 = 8) saturasi dalam pengolahan besar
nilai-nilai n. Speedups lebih lanjut dicapai jika 1'] [' 1 meningkat
untuk peningkatan jumlah prosesor logis yang tersedia.
Hal ini menempatkan maju konsep memanfaatkan pada banyak-inti
menghitung kemampuan GPU prosesor untuk tujuan umum
komputasi, yang akan dibahas dalam bagian berikut.

IV. PARALLEL BLOOM FILTER USING CUDA ON A

MANY CORE ARCHITECTURE
In an effort to further improve the performance speedup of
the parallel Bloom filter string searching algorithm, this
section proposes a parallel Bloom filter algorithm design by
utilizing the CUDA parallel computing platform on a GPU
processor. By using the CUDA parallel computing platform,
application threads executed in a GPU are organized in blocks
and a block is executed by a streaming multiprocessor unit.
By definition, a parallel application developed using
CUDA contains a heterogeneous architecture, whereby serial
portions of an algorithm are executed on the host (i.e., CPU)
whereas the parallel portion of the application is executed on
the device (i.e., GPU) as a kernel [10]. The kernel is executed
as an array of threads, in parallel. The host and device
memories are separate entities with no coherence [11]. As
such, explicit data transfer from the CPU memory to the GPU
memory is required. This is done by allocating memory on the
device and then transferring data from the host memory to the
allocated device memory. After device execution, resultant
data is transferred back from the device to the host memory
for results tabulation and storage. When the size of the data
transferred is large, the blocks of threads are queued for
execution; leading to a long execution time which might
exceed the run time limit. As a result, data processing has to
be performed in batches [4]. A fixed batch size of 50,000
strings is chosen to be read from host memory into device
memory for both filter insertion and searching processes.
Smaller batch size is feasible but not recommended as
additional constant overhead is generated each time data
transfer is invoked. Hence, fewer invocation of copy operation
is preferred. With batch processing, values stored in the
respective offset tables for word insertion and query searching
will be invalid for the subsequent batches of data. A CUDA
kernel is launched in order to calculate the offset position of
each string in each data batch. The actual offset of each string
(of the current batch) would be: the value in the original offset
table minus the total length of previously processed strings.
In both filter insertion and searching, each block processes
one string. Hence, the number of blocks per kernel invocation
is set to 50,000. The string is copied from the GPU global
memory into the shared memory to allow faster memory
access by threads within the block. Note that k is maintained at
500. Therefore, the number of threads per block is set to 500
such that each thread within the same block performs a
different hash function on the same string. The CUDA thread
identifier is used to obtain the associated element in the sal t
array while the CUDA block identifier is used to obtain the
associated string element in the batch.

IV. PARALEL BLOOM PENYARING MENGGUNAKAN CUDA PADA A

BANYAK INTI ARSITEKTUR
Dalam upaya untuk lebih meningkatkan kinerja speedup dari
dengan string penyaring mekar paralel algoritma, pencarian ini
Bagian mengusulkan Bloom penyaring algoritma desain paralel oleh
memanfaatkan platform pada GPU komputasi paralel CUDA
prosesor. Dengan menggunakan platform komputasi paralel CUDA,
benang aplikasi yang dijalankan dalam GPU yang disusun dalam blok
dan blok yang dijalankan oleh unit multiprosesor streaming.
Menurut definisi, sebuah aplikasi paralel dikembangkan dengan menggunakan
CUDA berisi arsitektur yang heterogen, dimana serial
Bagian dari algoritma dijalankan pada tuan rumah (yaitu, CPU)
sedangkan bagian paralel aplikasi dijalankan pada
perangkat ini (yaitu, GPU) sebagai sebuah kernel [10]. Kernel dijalankan
sebagai array benang, secara paralel. Host dan perangkat
kenangan adalah entitas yang terpisah dengan tidak koherensi [11]. Sebagai
seperti itu, transfer data eksplisit dari memori CPU untuk GPU
memori diperlukan. Hal ini dilakukan dengan mengalokasikan memori pada
perangkat dan kemudian mentransfer data dari memori host untuk
mengalokasikan memori perangkat. Setelah perangkat eksekusi, resultan
data yang ditransfer kembali dari perangkat memori host
untuk hasil tabulasi dan penyimpanan. Ketika ukuran data
ditransfer adalah besar, blok benang yang antri untuk
eksekusi; mengarah ke waktu eksekusi lama yang mungkin
melebihi batas waktu yang berjalan. Sebagai akibatnya, pengolahan data yang
dilakukan dalam batch [4]. Tetap batch ukuran 50.000
string yang dipilih untuk dibaca dari host memori ke perangkat
memori untuk penyisipan filter dan menelusuri proses.
Ukuran batch yang lebih kecil layak tapi tidak direkomendasikan sebagai
tambahan overhead konstan yang dihasilkan setiap data time
transfer yang dipanggil. Oleh karena itu, lebih sedikit doa copy operasi
lebih disukai. Dengan batch processing, nilai-nilai yang disimpan dalam
masing-masing tabel offset untuk penyisipan kata dan permintaan pencarian
akan menjadi tidak valid untuk batch berikutnya data. CUDA
kernel diluncurkan untuk menghitung posisi offset
setiap string dalam setiap kumpulan data. Offset sebenarnya dari setiap string
(dari kumpulan saat ini) akan menjadi: nilai dalam offset asli
Tabel minus total panjang string sebelumnya diproses.
Dalam kedua penyisipan filter dan mencari, setiap blok proses
satu string. Oleh karena itu, jumlah blok per kernel doa
diatur ke 50.000. String disalin dari GPU global
memori ke memori bersama agar lebih cepat memori
akses oleh thread dalam blok. Perhatikan bahwa k dikekalkan di
500. oleh karena itu, jumlah untaian per blok diatur ke 500
sedemikian rupa sehingga setiap benang dalam blok yang sama melakukan
fungsi hash berbeda pada string yang sama. Kain CUDA
pengenal digunakan untuk mendapatkan elemen yang terkait dalam sal t
array sementara CUDA blok pengenal digunakan untuk mendapatkan
terkait Tali serut di batch.

2013 IEEE Conference on Open Systems (ICOS), December 2 - 4, 2013, Sarawak, Malaysia
I String .49999
--- ----,
r--------!
: SM 7
Bloom Filter Bits Array
I Queued blocks
SM 7
Block (21.0.0)
(String 21)
Block (22.0.0)
(String 22)
Block (23.0.0)
(String 23)
ll1rcad (99.0.0)
(Hash function
number 500)
:
:
:
:
:
:
.:
Figure 6. Execution Model for filter insertion (for one batch of data with batch
size of 50,000) using CUDA

Gambar 6. Eksekusi Model untuk penyisipan filter (untuk satu batch data dengan batch
ukuran 50.000) menggunakan CUDA

I Qucry 0 I Que!)' I I ;'cry 2 I I Query 49999 1

r------'-,-------- ----,
r-------
: $1\,1 7
I Qm!ucd blocks
SM 7
Block (21.0.0)
(Query 21)
Block (22.0.0)
(Query 22)
Block (23.0.0)
(Query 23)
--- ------
Block(5,O,O)
II (Hash Th,,,d number function (0,0,0) I) I (Hash TIm"d Ilumber function (1.0,0) 2) I (Hash
TIm"d numlx:r function (2,0,0) 3) I I TI""d (Hash number function (499,0,0) 500)
\,. ./
Bloom Filter Bits Array
Query Result Array
I 0 I ", I ; I I 49999 I
Figure 7, Execution Model for filter search (for one batch of data with batch
size of 50,000) using CUDA
Fig. 6 illustrates the execution model of the Bloom filter
insertion process using CUDA. For filter insertion, each thread
will set one of the elements in the m bit table array after
calculating the associated index. Similar to the multi-core
implementation of the Bloom filter algorithm in Section 3, an
atomic operation is performed when writing into m. The use of
the atomic feature in CUDA minimizes race condition as the
writing operation is performed without interference from other
threads when writing to different locations of m.
5
Fig. 7 illustrates the execution model of the Bloom filter
searching process using CUDA. An array (in the GPU global
memory) stores the result of the filter search function. Prior to
invoking the kernel, the entire array is set with a logical true
value. Similar to filter insertion, each block performs
searching for one query and each thread within the block
performs a hash function on the same query. Each thread also
computes the bit-table index and checks the bit-table. If any of
the threads within the block finds that the bit-table is not set,
the result array at the index position indicated by the block
identifier will be set to fal se. Atomic operation is not
needed for this kernel function because only threads within the
same block will write to the same array location and the
logical value written is the same (i.e., which is fal se)
regardless of which thread is writing to it. The results are then
copied from the GPU memory to the CPU memory at the end
of kernel computation.
Replicating the test setup in the aforementioned sections, a
performance analysis was carried out to evaluate the
effectiveness of the many-core parallel Bloom filter algorithm
using CUDA, in comparison with the serial and multi-core
parallel Bloom filter algorithms. The setup also includes an
NVIDIA Quadro 4000 GPU processor with 256 cores (each at
950 MHz operating frequency), which are congregated
between eight streaming multiprocessors and with 2GBytes of
total GPU memory. Table I summarizes device property of the
NVIDIA Quadro 4000 GPU processor.

Mekar Filter bit Array

Array hasil query
Saya 0 saya ", saya; Saya saya 49999 saya
Gambar 7, eksekusi Model untuk filter pencarian (untuk satu batch data dengan batch
ukuran 50.000) menggunakan CUDA
Gambar 6 menggambarkan model eksekusi Bloom penyaring
penyisipan proses menggunakan CUDA. Untuk filter penyisipan, setiap benang
akan membuat salah satu elemen dalam array meja bit m setelah
menghitung indeks terkait. Mirip dengan multi-core
pelaksanaan Bloom penyaring algoritma dalam bagian 3,
operasi atomik dilakukan ketika menulis ke m. Penggunaan
Fitur atom di CUDA meminimalkan kondisi ras sebagai
menulis operasi dilakukan tanpa gangguan dari lain
benang ketika menulis ke lokasi yang berbeda m.
5
Gambar 7 menggambarkan model eksekusi Bloom penyaring
proses pencarian menggunakan CUDA. Array (dalam GPU global
memori) menyimpan hasil fungsi pencarian filter. Sebelum
menerapkan kernel, seluruh array diatur dengan benar Logis
nilai. Mirip dengan filter penyisipan, setiap blok melakukan
mencari satu query dan setiap benang dalam blok
melakukan fungsi hash di query yang sama. Setiap benang juga
menghitung indeks bit-tabel dan cek tabel bit. Jika salah satu
Thread dalam blok menemukan bahwa tabel bit tidak diset,
array hasil pada posisi indeks ditunjukkan oleh blok
pengenal akan ditetapkan untuk fal se. operasi atomik bukanlah
diperlukan untuk fungsi kernel ini karena hanya benang dalam
blok sama akan menulis ke berbagai lokasi yang sama dan
Logis nilai ditulis adalah sama (yaitu, yang adalah fal se)
Terlepas dari benang yang menulis untuk itu. Hasil yang kemudian
disalin dari GPU memori ke memori CPU pada akhir
komputasi kernel.
Replikasi setup tes di bagian tersebut,
Analisis kinerja dilakukan untuk mengevaluasi
efektivitas dari banyak-core paralel Bloom penyaring algoritma
menggunakan CUDA, dibandingkan dengan serial dan multi-core
paralel algoritma filter mekar. Setup juga mencakup
NVIDIA Quadro 4000 GPU prosesor dengan 256 Core (masing-masing di
950 MHz operasi frekuensi), yang adalah berkumpul
antara delapan streaming multiprocessors dan dengan 2GBytes dari
jumlah memori GPU. Meja saya meringkas properti perangkat
NVIDIA Quadro 4000 GPU prosesor.

TABLE L NVIDIA QUADRO 4000 DEVICE PROPERTIES,

Number of streaming multiprocessors (SM) 8
Number of CUDA Cores per SM 32
Number of threads per warp 32
Maximum number of threads per SM 1536
Maximum number of warps per SM 48
Maximum number of blocks per SM 8
By referring to the GPU device property in Table I, the
maximum number of resident blocks per SM is limited to
eight. However, since each block is launched with 500 threads
in line with k = 500, only 3 blocks can reside in an SM due to
the maximum limit of resident threads per SM (i.e., 1536
threads), which are in line with design of Fig. 6 and Fig. 7.
Since there are 8 SMs for this device, a maximum of 24 blocks
are executed concurrently. The rest of the blocks will be
queued for subsequent concurrent execution. Threads in each
block are grouped into warps of size 32. Hence, there are 16
warps in a block, giving a total of 48 warps in an SM. The SM
is thus considered to have achieved maximum occupancy
under these conditions. The execution of a warp is scheduled
by the warp schedulers in the SM. The execution time for both
the filter insertion and search operations includes the time
taken for data transfer between the host and the device. Fig. 8
illustrates the average operation time (i.e., for both insertion
and searching) of the proposed parallel Bloom filter algorithm
implemented using CUDA in comparison with the serial
Bloom filter algorithm. In addition, Fig. 8 also highlights the
performance speedup (green circle) to analyze the scale of
operation time improvement of the parallel Bloom filter
algorithm using CUDA against the serial Bloom filter
algorithm.

TABEL L NVIDIA QUADRO 4000 PROPERTI PERANGKAT,

Jumlah streaming multiprocessors (SM) 8
Jumlah Core CUDA per SM 32
Jumlah thread per warp 32
Jumlah maksimum benang per SM 1536
Jumlah maksimum warps per SM 48
Maksimum jumlah blok per SM 8
Dengan mengacu ke properti perangkat GPU yang di meja saya,
jumlah maksimum penduduk blok per SM terbatas
delapan. Namun, karena setiap blok diluncurkan dengan 500 benang
sejalan dengan k = 500, hanya 3 blok dapat berada di SM karena
batas maksimum benang penduduk per SM (yaitu, 1536
benang), yang sesuai dengan desain gambar. 6 dan 7 gambar.
Karena ada 8 SMs untuk perangkat ini, maksimum 24 blok
dijalankan secara bersamaan. Sisanya blok akan
antrian untuk eksekusi bersamaan berikutnya. Thread di masing-masing
blok dikelompokkan menjadi warps ukuran 32. Oleh karena itu, ada 16
warps di blok, memberikan total 48 warps di SM. SM
dengan demikian dianggap telah mencapai hunian maksimum
di bawah kondisi ini. Pelaksanaan warp dijadwalkan
oleh Penjadwal warp di SM. Waktu eksekusi untuk kedua
operasi penyisipan dan Cari filter yang mencakup waktu
diambil untuk transfer data antara host dan perangkat. Gambar 8
menggambarkan waktu rata-rata operasi (i.e., untuk penyisipan kedua
dan mencari) yang diusulkan mekar paralel algoritma filter
diimplementasikan menggunakan CUDA dibandingkan dengan serial
Bloom penyaring algoritma. Selain itu, Gambar 8 juga menyoroti
kinerja speedup (lingkaran hijau) untuk menganalisis skala
peningkatan waktu operasi paralel mekar filter
algoritma menggunakan CUDA terhadap serial Bloom penyaring
algoritma.

2013 IEEE Conference on Open Systems (ICOS), December 2 - 4, 2013, Sarawak, Malaysia
400,000
360,000
320,000
'00' 280,000
2, 240,000
. 200,000
160,000
"
"
" 120,000
p.,
80,000
40,000
0
-
E!= --'- Serial Bloom filter
-+-Parallel Bloom filter using CUDA

--e --Performance Speedup

E==
l===- =
5.20
4.80
, 4.40 4.00 0- OJ
3.60 ]
I==-F 2.80 3.20 m 0- '"
.. 2.40 " "
2.00
1.60 1.20
0.80 "-
0.40
0.00
1.00E+03 1.00E+04 1.00E+05 1.00E+06 1.00E+07
Number of strings, 11
Figure 8. Performance analysis of a parallel Bloom filter algorithm using
CUDA against a serial Bloom filter for an increasing n.
Results from Fig. 8 also suggest increased speedups of the
proposed parallel Bloom filter algorithm using CUDA against
the serial Bloom filter algorithm. For n = 10,000,000, the
proposed parallel algorithm on CUDA registered a 69 second
computational time, which translates into an improved
perfonnance speedup of S.Sx against the serial Bloom filter
algorithm.
Although the proposed algorithm exploits the use of shared
memory within blocks with the purpose of reducing the
computational time, the M bit-table remained in the GPU
global memory. This is because updates to the M bit-table
must be visible to all threads. Consequently, the performance
of the algorithm was affected due to the high latency on
continuous GPU global memory access and in addition to the
latency caused by data transfer between host and device
memory. In spite of this limitation, as a whole, the batch size
concept used in the proposed design did exhibit improved
performance speedups against a serial Bloom filter algorithm.

Jumlah senar, 11
Gambar 8. Analisis kinerja paralel Bloom penyaring algoritma menggunakan
CUDA terhadap serial Bloom penyaring untuk n meningkat.
Hasil dari gambar 8 juga menunjukkan peningkatan speedups dari
diusulkan paralel Bloom penyaring menggunakan algoritma CUDA terhadap
serial Bloom penyaring algoritma. Untuk n = 10.000.000,-
algoritma paralel yang diusulkan pada CUDA terdaftar kedua 69
waktu komputasi, yang diterjemahkan ke dalam peningkatan
speedup perfonnance dari S.Sx terhadap serial Bloom penyaring
algoritma.
Meskipun yang diusulkan algoritma eksploitasi penggunaan bersama
memori blok dengan tujuan mengurangi
komputasi waktu, tabel bit M tetap di GPU
Global memori. Hal ini karena pembaruan tabel bit M
harus terlihat untuk semua thread. Akibatnya, kinerja
dari algoritma yang terpengaruh karena latency tinggi pada
terus-menerus GPU global memori akses dan di samping
latensi yang disebabkan oleh transfer data antara host dan perangkat
memori. Walaupun pembatasan ini, secara keseluruhan, batch ukuran
konsep yang digunakan dalam desain diusulkan lakukan menunjukkan peningkatan
kinerja speedups terhadap sebuah serial Bloom penyaring algoritma.

120,000
100.000
'";;;' 80.000
5
E 60,000
t::::
m
8 40,000
ct
20.000
==- , -----==f ------..........
,1
--+-Parallel Bloom filter using OpenMP {-
--+-Parallel Bloom filter using CUDA I
--e --Performance Speedup
I I I ""#
==- -- I
1.60
1.40
1.20 '
-g
1.00 8.
m
0.80 8
"
0.60 E

0.40 t5
"-
0.20
1.00E+03 1.00E+04 1.00E+05 1.00E+06
0.00
1.00E+07
Number of strings, 11
Figure 9. Perfonnance analysis of a parallel Bloom filter algorithm using
CUDA against a parallel Bloom filter on a multicore architecture.
To further evaluate the performance between the proposed
parallel Bloom filter algorithm using CUDA and the
benchmarked multi-core parallel Bloom filter algorithm, Fig. 9
compares the computational performance between these two
algorithms. Fig. 9 also computes the performance speedup
between the benchmarked and proposed parallel Bloom filter
algorithms (green circle). Results from Fig. 9 undoubtedly
exhibits noticeable performance improvements of the
proposed parallel Bloom filter algorithm using CUDA to that
of the multi-core version using OpenMP with a peak
performance speedup of 1.6Sx for n = 10,000,000 strings.
6

Jumlah senar, 11
Gambar 9. Perfonnance analisis penggunaan paralel Bloom penyaring algoritma
CUDA terhadap filter mekar paralel pada arsitektur multicore.
Untuk lebih lanjut mengevaluasi kinerja antara usulan regu-
paralel algoritma Bloom penyaring menggunakan CUDA dan
benchmarked multi-core paralel Bloom penyaring algoritma, 9 Gbr
membandingkan kinerja komputasi antara kedua
algoritma. Gambar 9 juga menghitung kinerja speedup
antara benchmarked dan diusulkan paralel Bloom penyaring
algoritma (lingkaran hijau). Hasil dari 9 Gbr tidak diragukan lagi
Pameran nyata kinerja perbaikan
diusulkan paralel Bloom penyaring menggunakan algoritma CUDA yang
Versi multi core menggunakan OpenMP dengan puncak
kinerja speedup dari 1-.6sx untuk n = 10.000.000 string.
6

V. CONCLUSION
In this paper, the underlying architecture of a serial Bloom
filter was analyzed in identifying the performance impact for
large datasets. A parallel multi-core Bloom filter algorithm
using software application threads was implemented as
benchmark. Despite exhibiting performance speedups of up
3.3x for n = 10,000,000 against a serial Bloom filter
algorithm, the limited number of logical processors (11l' 1= 8)
on a multi-core architecture constrained the speedup levels. As
such, to improve the speedup, this paper proposed a parallel
many-core Bloom filter algorithm using the CUDA parallel
computing platform based on a batch string processing
process. The proposed algorithm improved the performance
speedup to S.Sx against a serial Bloom filter algorithm.
However, latency in data transfer between host and device
memory and the approach to classify M within the GPU
global memory limited the perfonnance speedup.
Optimization in the design of data transfer between host and
device memory should be given additional attention as future
work to further improve the performance speedup.
VI. ACKNOWLEDGMENT
This research was done under Joint Lab of "NVIDIA - HP
- MIMOS GPU R&D and Solution Center", which was
established October 2012. Funding for the work came from
MOST!, Malaysia.

V. KESIMPULAN
Dalam tulisan ini, arsitektur yang mendasari mekar serial
Filter dianalisis dalam mengidentifikasi dampak kinerja
dataset besar. Multi-core Bloom penyaring algoritma yang paralel
menggunakan perangkat lunak aplikasi benang dilaksanakan sebagai
patokan. Meskipun menunjukkan kinerja speedups dari atas
3.3 x untuk n = 10,000,000 terhadap serial Bloom penyaring
algoritma, terbatasnya jumlah prosesor logis (11l ' 1 = 8)
arsitektur multi-core dibatasi tingkat speedup. Sebagai
seperti itu, untuk meningkatkan speedup, karya ini diusulkan paralel
banyak-core Bloom penyaring menggunakan CUDA paralel algoritma
platform komputasi berdasarkan pengolahan string batch
proses. Algoritma yang diusulkan peningkatan kinerja
speedup untuk S.Sx terhadap sebuah serial Bloom penyaring algoritma.
Namun, latency data transfer antara host dan perangkat
memori dan pendekatan untuk mengklasifikasikan M dalam GPU
Global memori terbatas perfonnance speedup.
Optimasi dalam desain data transfer antara host dan
memori perangkat harus diberikan perhatian tambahan sebagai masa depan
bekerja untuk lebih meningkatkan kinerja speedup.
VI. PENGAKUAN
Penelitian dilakukan di bawah bersama Lab "NVIDIA - HP
-MIMOS GPU R&D dan pusat solusi ", yang
Didirikan Oktober 2012. Pendanaan untuk pekerjaan berasal dari
PALING!, Malaysia.

REFERENCES
[1] T. H. Connen, C. E. Leiserson, R. L. Rivest, and C. Stein, "Introduction
to algorithms," 3rd ed., McGraw-Hili Education, 2001, pp. 253-255.
[2] 1. Chai and 1. D. White, "Structuring data and building algorithms,"
Updated edition, McGraw-Hill Education, 2009, pp. 263-275.
[3] C. Zhiwang, X. Junggang, and S. Jian, "A multi-layer bloom filter for
duplicated URL detection," in the 3rd Int!. Conf on Advanced Computer
Theory and Engineering 2010, pp. 586-591, China, August 2010.
[4] L. B. Costa, S. Al-Kiswany, and M. Ripeanu, "GPU support for batch
oriented workload," in IEEE 28th IntI. Perf Compo and Comm. Conj, pp.
231-238, USA, December 2009.
[5] A. Natarajan, S. Subramanian, and K. Premalatha, "A comparative study
of cuckoo search and bat algorithm for bloom filter optimisation in spam
filtering," IntI. 1. of Bio-Inspired Computation, vol. 4, no.2, pp. 89-99,
2012.
[6] B. Chazelle, J. Kilian, R. Rubinfield, and A. Tal, "The bloomier filter: an
etlicient data structure for static support lookup tables," in Proc. of the
Fifteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pp.
30-39, USA, January 2004.
[7] N. S. Artan, K. Sinkar, 1. Patel, and H. 1. Chao, "Aggregated bloom
filters for intrusion detection and prevention hardware," in the IEEE
Global Telecommunications Conj, pp. 349-354, USA, November 2007.
[8] D. Eppstein and M.T. Goodrich, "Space-etlicient straggler identification
in round-trip data streams via newton's identities and invertible bloom
filters," LNCS, vol. 4619, pp. 637-648, Aug. 2007.
[9] A. Partow (2012, April 3). General-purpose hash function algorithms.
[Online]. Available:
http://www.partow.net/programminglhashfunctions/index.html.
[10] Y. Liu, L. J. Guo, J. B. Li, M. R. Ren, and K. Q. Li, "Parallel algorithms
for approximate string matching with k mismatches on CUDA," in IEEE
26th IntI. Parallel and Distributed Processing Symposium Workshop &
PHD Forum, pp. 2414-2422, China, May 2012.
[ll] T-y' Liang, Y-W. Chang, and H-F. Li, "A CUDA programming toolkit
on grids," IntI. J. of Grid and Utility Comp., vol. 3, no. 2-3, pp. 97-111,
July 2012.

TRANSLATE