bloom.h
#pragma once
#include "bitmap.h"
#define BloomHashCount 2
typedef uint64_t (*BloomHash)(const char*);
typedef struct BloomFilter{
Bitmap bm;
BloomHash bloom_hash[BloomHashCount];
} BloomFilter;
void BloomFilterInit(BloomFilter* bf);
void BloomFilterDestroy(BloomFilter* bf);
void BloomFilterrInsert(BloomFilter* bf, const char* str);
int BloomFilterIsExist(BloomFilter* bf, const char* str);
bloom.c
#include "bloom.h"
#include <stdlib.h>
#include "hash_func.h"
void BloomFilterInit(BloomFilter* bf){
if(bf == NULL){
return;
}
BitmapInit(&bf->bm, 1000);
bf->bloom_hash[0] = SDBMHash;
bf->bloom_hash[1] = BKDRHash;
return;
}
void BloomFilterDestroy(BloomFilter* bf){
if(bf == NULL){
return;
}
bf->bloom_hash[0] = NULL;
bf->bloom_hash[1] = NULL;
BitmapDestroy(&bf->bm);
return;
}
void BloomFilterrInsert(BloomFilter* bf, const char* str){
if(bf == NULL || str == NULL){
return;
}
size_t i = 0;
for(;i < BloomHashCount;++i){
uint64_t hash = bf->bloom_hash[i](str) % 1000;
BitmapSet(&bf->bm, hash);
}
return;
}
int BloomFilterIsExist(BloomFilter* bf, const char* str){
if(bf == NULL || str == NULL){
return 0;
}
size_t i = 0;
for(;i < BloomHashCount;++i){
uint64_t hash = bf->bloom_hash[i](str) % 1000;
int ret = BitmapTest(&bf->bm, hash);
if(ret == 0){
return 0;
}
}
return 1;
}
hash_func.h
#pragma once
#include <stddef.h>
#include <stdint.h>
uint64_t SDBMHash(const char* str);
uint64_t BKDRHash(const char* str);
hash_func.c
#include "hash_func.h"
#include <stdio.h>
uint64_t SDBMHash(const char* str){
(void)str;
return 0;
}
uint64_t BKDRHash(const char* str){
(void)str;
return 0;
}
bitmap.h
#pragma once
#include <stdint.h>
typedef struct Bitmap{
uint64_t* data;
uint64_t capacity;
} Bitmap;
int BitmapTest(Bitmap* bm, uint64_t index);
void BitmapInit(Bitmap* bm, uint64_t capacity);
void BitmapDestroy(Bitmap* bm);
void BitmapSet(Bitmap* bm, uint64_t index);
void BitmapUnset(Bitmap* bm, uint64_t index);
void BitmapFill(Bitmap* bm);
void BitmapClear(Bitmap* bm);
bitmap.c
#include "bitmap.h"
#include <stdlib.h>
#include <string.h>
uint64_t GetSize(uint64_t capacity){
uint64_t size = capacity / (sizeof(uint64_t)*8) + 1;
return size;
}
void BitmapInit(Bitmap* bm, uint64_t capacity){
if(bm == NULL){
return;
}
bm->capacity = capacity;
uint64_t size = capacity / (sizeof(bm->data[0])*8) + 1;
bm->data = (uint64_t*)malloc(sizeof(uint64_t)*size);
memset(bm->data, 0, sizeof(uint64_t)*size);
return;
}
void BitmapDestroy(Bitmap* bm){
if(bm == NULL){
return;
}
bm->capacity = 0;
free(bm->data);
return;
}
void GetOffset(uint64_t index, uint64_t* n, uint64_t* offset){
*n = index / (sizeof(uint64_t)*8);
*offset = index % (sizeof(uint64_t)*8);
return;
}
int BitmapTest(Bitmap* bm, uint64_t index){
if(bm == NULL || index >= bm->capacity){
return 0;
}
uint64_t n, offset;
GetOffset(index, &n, &offset);
uint64_t ret = bm->data[n] & (0x1ul << offset);
return ret > 0 ? 1 : 0;
}
void BitmapSet(Bitmap* bm, uint64_t index){
if( bm == NULL || index >= bm->capacity ){
return;
}
uint64_t n, offset;
GetOffset(index, &n, &offset);
bm->data[n] |= (0x1ul << offset);
return;
}
void BitmapUnset(Bitmap* bm, uint64_t index){
if( bm == NULL || index >= bm->capacity ){
return;
}
uint64_t n, offset;
GetOffset(index, &n, &offset);
bm->data[n] &= ~(0x1ul << offset);
return;
}
void BitmapFill(Bitmap* bm){
if(bm == NULL){
return;
}
uint64_t size = GetSize(bm->capacity);
memset(bm->data,0xff ,sizeof(uint64_t)*size);
return;
}
void BitmapClear(Bitmap* bm){
if(bm == NULL){
return;
}
uint64_t size = GetSize(bm->capacity);
memset(bm->data,0x0 ,sizeof(uint64_t)*size);
return;
}