148 lines
5.1 KiB
C++
148 lines
5.1 KiB
C++
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <cstring>
|
|
#include <map>
|
|
#include <fstream>
|
|
#include "init/params.h"
|
|
#include "init/BOBHash32.h"
|
|
#include "init/BOBHash64.h"
|
|
#include "init/ssummary.h"
|
|
#include "include/cmsketch.h"
|
|
#include "include/CSS.h"
|
|
#include "include/heavykeeper.h"
|
|
#include "include/LossyCounting.h"
|
|
#include "include/spacesaving.h"
|
|
|
|
using namespace std;
|
|
map <string, int> B, C;
|
|
struct node { string x; int y; } p[10000005];
|
|
ifstream fin("/home/zhang/桌面/heavykeeper/2016.dat", ios::in | ios::binary);
|
|
char a[105];
|
|
string Read()
|
|
{
|
|
fin.read(a, 8);
|
|
a[8] = '\0';
|
|
string tmp = a;
|
|
// for (int i=0; i < 13; i++)
|
|
//{
|
|
// tmp += a[i];
|
|
// }
|
|
// tmp += '\0';
|
|
return tmp;
|
|
}
|
|
int cmp(node i, node j) { return i.y > j.y; }
|
|
int main()
|
|
{
|
|
int MEM, K;
|
|
cin >> MEM >> K;
|
|
cout << "MEM=" << MEM << "KB" << endl << "Find top" << K << endl << endl;
|
|
cout << "preparing all algorithms" << endl;
|
|
int m = 100000; // the number of flows
|
|
// preparing heavykeeper
|
|
int hk_M;
|
|
for (hk_M = 1; 32 * hk_M * HK_d + 432 * K <= MEM * 1024 * 8; hk_M++); if (hk_M % 2 == 0) hk_M--;
|
|
heavykeeper* hk; hk = new heavykeeper(hk_M, K); hk->clear();
|
|
//preparing cmsketch
|
|
int cm_M;
|
|
for (cm_M = 1; 32 * cm_M * cm_d + 432 * K <= MEM * 1024 * 8; cm_M++); if (cm_M % 2 == 0) cm_M--;
|
|
cmsketch* cm; cm = new cmsketch(cm_M, K); cm->clear();
|
|
// preparing spacesaving
|
|
int ss_M;
|
|
for (ss_M = 1; 432 * ss_M <= MEM * 1024 * 8; ss_M++);
|
|
spacesaving* ss; ss = new spacesaving(ss_M, K);
|
|
|
|
// preparing LossyCounting
|
|
int LC_M;
|
|
for (LC_M = 1; 227 * LC_M <= MEM * 1024 * 8; LC_M++);
|
|
LossyCounting* LC; LC = new LossyCounting(K);
|
|
|
|
// preparing CSS
|
|
int css_M;
|
|
for (css_M = 1; 179 * css_M + 4 * css_M * log(css_M) / log(2) <= MEM * 1024 * 8; css_M++);
|
|
CSS* css; css = new CSS(css_M, K); css->clear();
|
|
// Inserting
|
|
for (int i = 1; i <= m; i++)
|
|
{
|
|
if (i % (m / 10) == 0) cout << "Insert " << i << endl;
|
|
string s = Read();
|
|
B[s]++;
|
|
hk->Insert(s);
|
|
ss->Insert(s);
|
|
LC->Insert(s, i / LC_M); if (i % LC_M == 0) LC->clear(i / LC_M);
|
|
css->Insert(s);
|
|
cm->Insert(s);
|
|
}
|
|
hk->work();
|
|
ss->work();
|
|
LC->work();
|
|
css->work();
|
|
cm->work();
|
|
cout << "preparing true flow" << endl;
|
|
// preparing true flow
|
|
int cnt = 0;
|
|
for (map <string, int>::iterator sit = B.begin(); sit != B.end(); sit++)
|
|
{
|
|
p[++cnt].x = sit->first;
|
|
p[cnt].y = sit->second;
|
|
}
|
|
sort(p + 1, p + cnt + 1, cmp);
|
|
for (int i = 1; i <= K; i++) C[p[i].x] = p[i].y;
|
|
|
|
// Calculating PRE, ARE, AAE
|
|
cout << "Calculating" << endl;
|
|
int hk_sum = 0, hk_AAE = 0; double hk_ARE = 0;
|
|
string hk_string; int hk_num;
|
|
for (int i = 0; i < K; i++)
|
|
{
|
|
hk_string = (hk->Query(i)).first; hk_num = (hk->Query(i)).second;
|
|
hk_AAE += abs(B[hk_string] - hk_num); hk_ARE += abs(B[hk_string] - hk_num) / (B[hk_string] + 0.0);
|
|
if (C[hk_string]) hk_sum++;
|
|
}
|
|
|
|
int cm_sum = 0, cm_AAE = 0; double cm_ARE = 0;
|
|
string cm_string; int cm_num;
|
|
for (int i = 0; i < K; i++)
|
|
{
|
|
cm_string = (cm->Query(i)).first; cm_num = (cm->Query(i)).second;
|
|
cm_AAE += abs(B[cm_string] - cm_num); cm_ARE += abs(B[cm_string] - cm_num) / (B[cm_string] + 0.0);
|
|
if (C[cm_string]) cm_sum++;
|
|
}
|
|
|
|
int LC_sum = 0, LC_AAE = 0; double LC_ARE = 0;
|
|
string LC_string; int LC_num;
|
|
for (int i = 0; i < K; i++)
|
|
{
|
|
LC_string = (LC->Query(i)).first; LC_num = (LC->Query(i)).second;
|
|
LC_AAE += abs(B[LC_string] - LC_num); LC_ARE += abs(B[LC_string] - LC_num) / (B[LC_string] + 0.0);
|
|
if (C[LC_string]) LC_sum++;
|
|
}
|
|
|
|
int ss_sum = 0, ss_AAE = 0; double ss_ARE = 0;
|
|
string ss_string; int ss_num;
|
|
for (int i = 0; i < K; i++)
|
|
{
|
|
ss_string = (ss->Query(i)).first; ss_num = (ss->Query(i)).second;
|
|
ss_AAE += abs(B[ss_string] - ss_num); ss_ARE += abs(B[ss_string] - ss_num) / (B[ss_string] + 0.0);
|
|
if (C[ss_string]) ss_sum++;
|
|
}
|
|
|
|
int css_sum = 0, css_AAE = 0; double css_ARE = 0;
|
|
string css_string; int css_num;
|
|
for (int i = 0; i < K; i++)
|
|
{
|
|
css_string = (css->Query(i)).first; css_num = (css->Query(i)).second;
|
|
css_AAE += abs(B[css_string] - css_num); css_ARE += abs(B[css_string] - css_num) / (B[css_string] + 0.0);
|
|
if (C[css_string]) css_sum++;
|
|
}
|
|
printf("heavkeeper:\nAccepted: %d/%d %.10f\nARE: %.10f\nAAE: %.10f\n\n", hk_sum, K, (hk_sum / (K + 0.0)), hk_ARE / K, hk_AAE / (K + 0.0));
|
|
printf("LossyCounting:\nAccepted: %d/%d %.10f\nARE: %.10f\nAAE: %.10f\n\n", LC_sum, K, (LC_sum / (K + 0.0)), LC_ARE / K, LC_AAE / (K + 0.0));
|
|
printf("spacesaving:\nAccepted: %d/%d %.10f\nARE: %.10f\nAAE: %.10f\n\n", ss_sum, K, (ss_sum / (K + 0.0)), ss_ARE / K, ss_AAE / (K + 0.0));
|
|
printf("CSS:\nAccepted: %d/%d %.10f\nARE: %.10f\nAAE: %.10f\n\n", css_sum, K, (css_sum / (K + 0.0)), css_ARE / K, css_AAE / (K + 0.0));
|
|
printf("cmsketch:\nAccepted: %d/%d %.10f\nARE: %.10f\nAAE: %.10f\n\n", cm_sum, K, (cm_sum / (K + 0.0)), cm_ARE / K, cm_AAE / (K + 0.0));
|
|
return 0;
|
|
}
|