HEM5.cpp

#include "HEM5.h"

HEM5::HEM5(int type)
{
	numSub = 0;
	numDimension = atts;
	buckStep = (valDom - 1) / buks + 1;
	numBucket = (valDom - 1) / buckStep + 1;
	string TYPE = "HEM5DD";
	if (type == HEM5_DD_PARALLEL)
	{
		threadPool.initThreadPool(parallelDegree);
		TYPE += "-Parallel" + to_string(parallelDegree);
	}
	else if (type == HEM5_DD_AVXOR_PARALLEL)
	{
		threadPool.initThreadPool(parallelDegree);
		TYPE += "-avxOR" + to_string(BlockSize) + "-Parallel" + to_string(parallelDegree);
	}
	cout << "ExpID = " << expID << ". " + TYPE + ": bit exponent = " << be << ", bucketStep = " << buckStep
		 << ", numBucket = " << numBucket << endl;

	//bucketSub.resize(numBucket);
	data[0].resize(numDimension, vector<vector<Combo>>(numBucket));
	data[1].resize(numDimension, vector<vector<Combo>>(numBucket));

	if (be == -1)
		numBits = be2;
	else
		numBits = pow(2, be); // 每锟斤拷维锟斤拷锟斤拷lowValue锟斤拷应锟斤拷bits锟斤拷锟斤拷锟斤拷锟�?
	//if (numBits > 1)
	fullBits.resize(numDimension); // 维锟斤拷锟斤拷锟斤拷锟斤拷远锟斤拷锟戒，锟斤拷锟斤拷只锟斤拷要resize一锟斤拷

//else bitStep = numBucket >> 1;

	doubleReverse[0] = new bool* [numDimension];
	doubleReverse[1] = new bool* [numDimension];
	endBucket[0] = new int* [numDimension];
	endBucket[1] = new int* [numDimension];
	bitsID[0] = new int* [numDimension];
	bitsID[1] = new int* [numDimension];
	_for(i, 0, numDimension)
	{
		doubleReverse[0][i] = new bool[numBucket];
		doubleReverse[1][i] = new bool[numBucket];
		endBucket[0][i] = new int[numBucket];
		endBucket[1][i] = new int[numBucket];
		bitsID[0][i] = new int[numBucket];
		bitsID[1][i] = new int[numBucket];
	}

	fix[0].resize(numDimension, vector<int>(numBucket + 1));
	fix[1].resize(numDimension, vector<int>(numBucket + 1));
}

HEM5::~HEM5()
{
	_for(i, 0,
		numDimension) delete[] doubleReverse[0][i], doubleReverse[1][i], endBucket[0][i], endBucket[1][i], bitsID[0][i], bitsID[1][i];
	delete[] endBucket[0], endBucket[1], bitsID[0], bitsID[1], doubleReverse[0], doubleReverse[1];
}

void HEM5::insert(IntervalSub sub)
{
	for (int i = 0; i < sub.size; i++)
	{
		IntervalCnt cnt = sub.constraints[i];
		Combo c;
		// int bucketID = cnt.lowValue / buckStep; // Bug: 锟斤拷锟斤被锟斤拷锟斤拷
		c.val = cnt.lowValue;
		c.subID = sub.id;
		data[0][cnt.att][cnt.lowValue / buckStep].push_back(c);
		c.val = cnt.highValue;
		data[1][cnt.att][cnt.highValue / buckStep].push_back(c);
	}
	numSub++;
}

void HEM5::insert_online(IntervalSub sub)
{
	Combo c;
	int b, bucketID;
	c.subID = sub.id;
	//if (numBits > 1) { // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷for循锟斤拷锟斤拷每锟轿讹拷锟叫讹拷一锟斤拷
	//_for(i, 0, sub.size) {
	//	fullBits[sub.constraints[i].att][sub.id] = 1;
	//}
	//}
	for (auto&& cnt : sub.constraints)
	{

		fullBits[cnt.att][sub.id] = 1;

		bucketID = cnt.lowValue / buckStep;
		c.val = cnt.lowValue;
		data[0][cnt.att][bucketID].push_back(c);
		if (doubleReverse[0][cnt.att][bucketID])
			b = bitsID[0][cnt.att][bucketID];
		else
			b = bitsID[0][cnt.att][bucketID] + 1;
		_for(q, b, numBits - 1) bits[0][cnt.att][q][sub.id] = 1;

		bucketID = cnt.highValue / buckStep;
		c.val = cnt.highValue;
		data[1][cnt.att][bucketID].push_back(c);
		if (doubleReverse[1][cnt.att][bucketID])
			b = bitsID[1][cnt.att][bucketID];
		else
			b = bitsID[1][cnt.att][bucketID] + 1;
		_for(q, b, numBits - 1) bits[1][cnt.att][q][sub.id] = 1;
	}
	numSub++;
}

bool HEM5::deleteSubscription(IntervalSub sub)
{
	int find = 0;
	IntervalCnt cnt;
	int b, bucketID, id = sub.id;

	//if (numBits > 1) { // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷for循锟斤拷锟斤拷每锟轿讹拷锟叫讹拷一锟斤拷
	_for(i, 0, sub.size)
	{
		fullBits[sub.constraints[i].att][id] = 0;
	}
	//}

	_for(i, 0, sub.size)
	{
		cnt = sub.constraints[i];

		bucketID = cnt.lowValue / buckStep;
		vector<Combo>::const_iterator it;
		for (it = data[0][cnt.att][bucketID].cbegin(); it != data[0][cnt.att][bucketID].cend(); it++)
			if (it->subID == id)
			{
				data[0][cnt.att][bucketID].erase(it); // it = 
				find++;
				break;
			}

		if (doubleReverse[0][cnt.att][bucketID])
			b = bitsID[0][cnt.att][bucketID];
		else
			b = bitsID[0][cnt.att][bucketID] + 1;
		_for(q, b, numBits - 1) bits[0][cnt.att][q][sub.id] = 0;

		bucketID = cnt.highValue / buckStep;
		for (it = data[1][cnt.att][bucketID].cbegin(); it != data[1][cnt.att][bucketID].cend(); it++)
			if (it->subID == id)
			{
				data[1][cnt.att][bucketID].erase(it); // it = 
				find++;
				break;
			}

		if (doubleReverse[1][cnt.att][bucketID])
			b = bitsID[1][cnt.att][bucketID];
		else
			b = bitsID[1][cnt.att][bucketID] + 1;
		_for(q, b, numBits - 1) bits[1][cnt.att][q][sub.id] = 0;
	}
	if (find == 2 * sub.size)
		numSub--;
	return find == 2 * sub.size;
}

// fullBits锟斤拷锟斤拷锟芥储锟侥版本
void HEM5::initBits()
{

	// 锟斤拷锟斤拷卸锟轿筹拷始锟斤拷
	_for(i, 0,
		numDimension) delete[] doubleReverse[0][i], doubleReverse[1][i], endBucket[0][i], endBucket[1][i], bitsID[0][i], bitsID[1][i];
	delete[] endBucket[0], endBucket[1], bitsID[0], bitsID[1], doubleReverse[0], doubleReverse[1];
	doubleReverse[0] = new bool* [numDimension];
	doubleReverse[1] = new bool* [numDimension];
	endBucket[0] = new int* [numDimension];
	endBucket[1] = new int* [numDimension];
	bitsID[0] = new int* [numDimension];
	bitsID[1] = new int* [numDimension];
	_for(i, 0, numDimension)
	{
		doubleReverse[0][i] = new bool[numBucket];
		doubleReverse[1][i] = new bool[numBucket];
		endBucket[0][i] = new int[numBucket];
		endBucket[1][i] = new int[numBucket];
		bitsID[0][i] = new int[numBucket];
		bitsID[1][i] = new int[numBucket];
	}
	bits[0].clear(), bits[1].clear();
	bits[0].resize(numDimension, vector<bitset<subs>>(numBits - 1));
	bits[1].resize(numDimension, vector<bitset<subs>>(numBits - 1));

	//// 前缀锟酵★拷锟斤拷缀锟斤拷锟斤拷锟斤拷, 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
	//_for(i, 0, numDimension) {
	//	_for(j, 1, numBucket) {
	//		fix[0][i][numBucket - 1 - j] = fix[0][i][numBucket - j] + data[0][i][numBucket - j].size();
	//		fix[1][i][j] = fix[1][i][j - 1] + data[1][i][j - 1].size();
	//	}
	//	// 锟斤拷锟斤拷锟斤拷锟斤拷暮痛锟斤拷锟斤拷锟斤拷一锟斤拷元锟斤拷锟斤拷
	//	fix[0][i][numBucket] = fix[0][i][0] + data[0][i][0].size();
	//	fix[1][i][numBucket] = fix[1][i][numBucket - 1] + data[1][i][numBucket - 1].size(); // Bug: 锟斤拷锟斤拷-1!!!
	//}

	// 前缀锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷)锟斤拷锟斤拷缀锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷锟斤拷锟斤拷)
	_for(i, 0, numDimension)
	{
		fix[0][i][numBucket] = 0;
		fix[0][i][numBucket - 1] = data[0][i][numBucket - 1].size();
		fix[1][i][0] = 0;
		_for(j, 1, numBucket)
		{
			fix[0][i][numBucket - 1 - j] = fix[0][i][numBucket - j] + data[0][i][numBucket - j - 1].size();
			fix[1][i][j] = fix[1][i][j - 1] + data[1][i][j - 1].size();
		}
		// 锟斤拷锟斤拷锟斤拷锟斤拷暮痛锟斤拷锟斤拷锟斤拷一锟斤拷元锟斤拷锟斤拷
		//fix[0][i][numBucket] = fix[0][i][0];  // Bug: 锟斤拷锟铰猴拷锟斤拷湛锟绞硷拷锟接筹拷锟斤拷系时fix[0][i][lowBktId]锟斤拷锟斤拷锟斤拷
		fix[1][i][numBucket] = fix[1][i][numBucket - 1] + data[1][i][numBucket - 1].size(); // Bug: 锟斤拷锟斤拷-1!!!
	}

	//if (numBits == 1) { // 只锟斤拷一锟斤拷bits时锟斤拷锟叫ｏ拷锟斤拷锟斤拷fullBits
	//	_for(i, 0, numDimension) {
	//		int halfWorkLoad = fix[0][i][0] >> 1; // subWorkLoadStep  fix[1][i][numBucket]
	//		int quarterWorkLoad = halfWorkLoad >> 1;
	//		// 锟斤拷一锟斤拷锟斤拷/前缀锟酵帮拷锟斤拷一锟诫订锟侥碉拷桶ID锟斤拷bit锟斤拷锟斤拷锟斤拷远锟斤拷锟矫革拷锟角碉拷lowHalfPoint锟斤拷highHalfPoint-1
	//		int lowHalfPoint = -1, lowQuarterPoint = -1, highHalfPoint = -1, highQuarterPoint = -1;
	//		_for(j, 0, numBucket) {
	//			if (lowQuarterPoint == -1 && fix[0][i][numBucket - 1 - j] >= quarterWorkLoad)
	//				lowQuarterPoint = numBucket - 1 - j;
	//			else if (lowHalfPoint == -1 && fix[0][i][numBucket - 1 - j] >= halfWorkLoad)
	//				lowHalfPoint = numBucket - 1 - j;

	//			if (highQuarterPoint == -1 && fix[1][i][j] >= quarterWorkLoad)
	//				highQuarterPoint = j;
	//			else if (highHalfPoint == -1 && fix[1][i][j] >= halfWorkLoad)
	//				highHalfPoint = j;
	//		}

	//		_for(j, 0, numBucket) {
	//			if (j < lowHalfPoint) { // 锟斤拷锟斤拷锟斤拷锟斤拷bitset
	//				bitsID[0][i][j] = 0;
	//				endBucket[0][i][j] = lowHalfPoint; // 锟斤拷锟斤拷锟斤拷小锟斤拷 lowCriticalPoint
	//				doubleReverse[0][i][j] = false;
	//			}
	//			else if (j < lowQuarterPoint) {
	//				bitsID[0][i][j] = 0;
	//				endBucket[0][i][j] = lowHalfPoint; // 锟斤拷 j 锟斤拷锟截凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�? lowCriticalPoint(锟斤拷锟斤拷锟斤拷)
	//				doubleReverse[0][i][j] = true;
	//				_for(k, 0, data[0][i][j].size()) // 桶锟斤拷每锟斤拷锟斤拷锟斤拷
	//					bits[0][i][0][data[0][i][j][k].subID] = 1;
	//			}
	//			else {
	//				bitsID[0][i][j] = -1;
	//				endBucket[0][i][j] = numBucket;
	//				doubleReverse[0][i][j] = false;
	//				_for(k, 0, data[0][i][j].size()) // 桶锟斤拷每锟斤拷锟斤拷锟斤拷
	//					bits[0][i][0][data[0][i][j][k].subID] = 1;
	//			}
	//			if (j < highQuarterPoint) { // 锟斤拷锟斤拷锟斤拷锟斤拷bitset
	//				bitsID[1][i][j] = -1;
	//				endBucket[1][i][j] = 0; // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷0
	//				doubleReverse[1][i][j] = false;
	//				_for(k, 0, data[1][i][j].size()) // 桶锟斤拷每锟斤拷锟斤拷锟斤拷
	//					bits[1][i][0][data[1][i][j][k].subID] = 1;
	//			}
	//			else if (j < highHalfPoint) {
	//				bitsID[1][i][j] = 0;
	//				endBucket[1][i][j] = highHalfPoint; // 锟斤拷 j 锟斤拷锟截凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诘锟斤拷锟�? highCriticalPoint
	//				doubleReverse[1][i][j] = true;
	//				_for(k, 0, data[1][i][j].size()) // 桶锟斤拷每锟斤拷锟斤拷锟斤拷
	//					bits[1][i][0][data[1][i][j][k].subID] = 1;
	//			}
	//			else {
	//				bitsID[1][i][j] = 0;
	//				endBucket[1][i][j] = highHalfPoint; // 锟斤拷 j-1 锟斤拷锟斤拷锟斤拷锟斤拷锟节碉拷锟斤拷 highHalfPoint, 锟斤拷锟斤拷前锟斤拷锟斤拷一锟斤拷
	//				doubleReverse[1][i][j] = false;
	//			}
	//		}
	//	}
	//	//cout << "HEM5DD Stop.\n";
	//	return;
	//}

	// 锟斤拷前应锟斤拷映锟戒到锟斤拷bitId, 桶id, 锟斤拷一锟斤拷锟劫界负锟截碉拷
	int lowBid, highBid, lowBktId, highBktId, lowSubWorkLoad, highSubWorkLoad;
	int subWorkLoadStep; // 每锟斤拷维锟斤拷锟较碉拷subWorkLoadStep锟斤拷锟斤拷同, 锟斤拷同一锟斤拷维锟斤拷锟较碉拷low/high subWorkLoadStep锟斤拷一锟斤拷锟斤拷
	_for(i, 0, numDimension)
	{

		// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�?
		if (fix[0][i][0] == 0)
		{
			_for(j, 0, numBucket)
			{
				bitsID[0][i][j] = -1;
				endBucket[0][i][j] = j;
				doubleReverse[0][i][j] = false;
				bitsID[1][i][j] = -1;
				endBucket[1][i][j] = j; // 锟斤拷锟斤拷锟斤拷锟斤拷锟节碉拷锟斤拷endBucket[1][i][j]
				doubleReverse[1][i][j] = false;
			}
			continue;
		}

		subWorkLoadStep = (fix[0][i][0] + numBits - 1) / numBits; // fix[1][i][numBucket]

		// 锟斤拷锟斤拷锟斤拷low/high锟斤拷锟角讹拷态锟斤拷, 锟斤拷锟斤拷锟斤拷锟斤拷锟杰癸拷锟斤拷同一锟斤拷partition/cell,
		// 锟斤拷锟斤拷锟斤拷low锟斤拷锟角达拷锟斤拷呖锟绞硷拷锟揭伙拷锟絪ubWorkLoadStep锟斤拷锟斤拷, 锟斤拷锟斤拷一锟斤拷
		// 锟斤拷锟竭达拷锟揭憋拷锟斤拷 剩锟洁负锟斤拷锟斤拷 锟斤拷始锟桔硷拷subWorkLoadStep, 锟斤拷锟斤拷锟斤拷锟絜ndBucket!
		// 0锟斤拷low桶一锟斤拷锟斤拷锟斤拷锟矫碉拷锟斤拷 (numBits - 2) 为锟铰憋拷锟絙itset
		// 锟斤拷锟揭伙拷锟酵耙伙拷锟斤拷貌锟斤拷锟絙itset
		// 锟斤拷锟斤拷: numBits=15, fix[0][i][0]=1000000, subWorkLoadStep=66667 (low锟较的猴拷14锟斤拷锟斤拷1, high锟较碉拷前14锟斤拷锟斤拷1)
		// fix[0][i][numBucket] / subWorkLoadStep=14, lowSubWorkLoad=66662
		lowBid = -1;
		lowBktId = numBucket;
		lowSubWorkLoad = fix[0][i][0] - (fix[0][i][0] - 1) / subWorkLoadStep * subWorkLoadStep;
		highBid = -1;
		highBktId = 0;
		highSubWorkLoad = subWorkLoadStep;

		// lowContain[i]=锟斤拷锟斤拷(锟斤拷一锟斤拷锟斤拷锟斤拷)lowSubWorkLoad+(i-1)*subWorkLoadStep锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷桶锟斤拷(i>0时)
		vector<int> lowContain(numBits + 1, numBucket);
		// highContain[i]=锟斤拷锟斤拷 i*subWorkLoadStep 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷桶锟斤拷
		vector<int> highContain(numBits + 1, 0);
		int li = 1, hi = 1; // lowContain锟斤拷highContain锟斤拷锟铰憋拷
		_for(j, 0, numBucket)
		{
			if (fix[1][i][j] >= highSubWorkLoad)
			{ // 前缀锟酵诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷0锟斤拷j-1锟斤拷锟斤拷锟斤拷锟酵帮拷锟斤拷锟�?
				highContain[hi++] = j; // bkt0 ~ bkt[highContain[hi]]-1 contains subWorkLoadStep*hi workload; highContain[hi]-1 is the right end bkt ID of the $hi group; hi means the old hi.
				highSubWorkLoad += subWorkLoadStep;
			}
			// 锟斤拷锟斤拷: fix[0][i][0]=1M, subWorkLoadStep=100000, numBits=10
			// li,lowSubWorkLoad = 1,100000; 2,200000; ... ; 9,900000; 10,1000000; 11,1100000
			if (fix[0][i][numBucket - j - 1] >= lowSubWorkLoad)
			{
				lowContain[li++] = numBucket - j - 1;
				lowSubWorkLoad += subWorkLoadStep;
			}
		}
		//lowContain[li] = 0; // 为啥锟斤拷锟斤拷越锟斤拷??? li==numBits+1锟斤拷
		if (hi == numBits) // Bug: 锟斤拷蠹父锟酵帮拷?锟斤拷锟绞県i锟斤拷锟斤拷for循锟斤拷锟斤拷锟斤拷锟接碉拷numBits+1
			highContain[hi] = numBucket;

		li = hi = 1; // 双锟截凤拷锟斤拷锟斤拷锟绞憋拷锟斤拷锟接︼拷锟斤拷锟揭伙拷说锟酵帮拷锟斤拷锟絚ontain锟斤拷锟斤拷锟叫碉拷锟铰憋拷, 锟斤拷实 li=lowBid+2, hi=highBid+2
		lowSubWorkLoad = fix[0][i][0] - (fix[0][i][0] - 1) / subWorkLoadStep * subWorkLoadStep;
		highSubWorkLoad = subWorkLoadStep;
		_for(j, 0, numBucket)
		{
			// 锟斤拷时锟斤拷锟节碉拷锟斤拷highSubWorkLoad锟斤拷, 锟斤拷锟斤拷锟斤拷bits, 锟斤拷为bits锟斤拷锟角碉拷j-1桶
			if (fix[1][i][j] >= highSubWorkLoad)
			{ // 锟斤拷一锟斤拷锟斤拷锟节碉拷锟斤拷锟劫斤拷锟斤拷桶(j-1锟斤拷, 前缀锟酵诧拷锟斤拷锟斤拷锟斤拷锟斤拷)锟斤拷为bitset锟斤拷锟角碉拷锟秸碉拷桶
				highSubWorkLoad += subWorkLoadStep;
				hi++;
				highBid++;
				highBktId = j; // == highContain[hi-1] ?
			}

			// Bug: 锟斤拷前锟斤拷锟斤拷, 锟斤拷蠹父锟酵帮拷?锟斤拷锟�?, 锟斤拷时highBid=numBits-1, 越锟斤拷锟斤拷, 直锟斤拷锟斤拷fullBL
			if (fix[1][i][j] == fix[1][i][numBucket])
			{
				bitsID[1][i][j] = numBits - 1;
				endBucket[1][i][j] = j; // bucket j does not need to be reversely marked because COMPARE step can ensure the correctness
				doubleReverse[1][i][j] = true;
			}
			else if (fix[1][i][j] - fix[1][i][highBktId] <
					 fix[1][i][highContain[hi]] - fix[1][i][j + 1])
			{ // Bug: 没锟叫硷拷highBktId
				bitsID[1][i][j] = highBid;
				endBucket[1][i][j] = highBktId; // 锟斤拷锟斤拷锟斤拷锟斤拷锟节碉拷锟斤拷endBucket[1][i][j]
				doubleReverse[1][i][j] = false;
			}
			else
			{
				bitsID[1][i][j] = hi - 1;              // highBid+1
				endBucket[1][i][j] = highContain[hi]; // 锟斤拷j锟斤拷锟揭憋拷锟斤拷锟斤拷小锟斤拷endBucket[1][i][j]
				doubleReverse[1][i][j] = true;
			}

			// 锟斤拷缀锟斤拷锟斤拷锟斤拷锟绞憋拷锟斤拷锟斤拷锟斤拷锟�?(锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�?, 锟斤拷锟斤拷锟斤拷锟斤拷j锟斤拷lowBktId锟斤拷lowContain[li]锟斤拷锟劫硷拷一锟斤拷锟斤拷lowContain[li]锟叫匡拷锟斤拷为0); -1+1省去锟斤拷
			// fix[0][i][j][numBucket]锟斤拷要锟斤拷0, 使fix[0][i][j][lowBktId]锟秸匡拷始为0
			// Bug: 锟斤拷前锟斤拷锟斤拷, 锟斤拷锟叫★拷募锟斤拷锟酵帮拷?锟斤拷锟�?, 锟斤拷锟斤拷锟斤拷锟斤拷, 直锟斤拷锟矫讹拷锟截凤拷锟斤拷
			if (fix[0][i][numBucket - j - 1] == fix[0][i][0])
			{
				bitsID[0][i][numBucket - j - 1] = numBits - 1;
				endBucket[0][i][numBucket - j - 1] = numBucket - j; // traverse to >= endBucket
				doubleReverse[0][i][numBucket - j - 1] = true;
			}
			else if (fix[0][i][numBucket - j] - fix[0][i][lowBktId] <
					 fix[0][i][lowContain[li]] - fix[0][i][numBucket - j - 1])
			{
				bitsID[0][i][numBucket - j - 1] = lowBid;
				endBucket[0][i][numBucket - j - 1] = lowBktId;
				doubleReverse[0][i][numBucket - j - 1] = false;
			}
			else
			{
				bitsID[0][i][numBucket - j - 1] = li - 1; // lowBktId+1
				endBucket[0][i][numBucket - j - 1] = lowContain[li];
				doubleReverse[0][i][numBucket - j - 1] = true;
			}

			// 锟斤拷时锟斤拷然锟斤拷锟节碉拷锟斤拷lowSubWorkLoad锟斤拷, 锟斤拷锟皆诧拷锟斤拷锟斤拷锟斤拷bits, 锟斤拷为bits要锟斤拷锟角碉拷j锟斤拷桶
			if (fix[0][i][numBucket - j - 1] >= lowSubWorkLoad)
			{
				lowSubWorkLoad += subWorkLoadStep;
				li++;
				lowBid++;
				lowBktId = numBucket - j - 1;
			}
		}
	}

	int subID, b; // 锟斤拷始锟斤拷锟斤拷锟斤拷锟斤拷锟铰憋拷
	_for(i, 0, numDimension)
	{ // 每锟斤拷维锟斤拷
		_for(j, 0, numBucket)
		{ // 每锟斤拷桶
			if (doubleReverse[0][i][j])
				b = bitsID[0][i][j]; // 锟斤拷小锟斤拷锟斤拷要锟斤拷锟斤拷锟絙its锟斤拷锟斤拷锟絀D
			else
				b = bitsID[0][i][j] + 1;
			_for(k, 0, data[0][i][j].size())
			{
				subID = data[0][i][j][k].subID;
				fullBits[i][subID] = 1; // numBits-1锟斤拷bits每锟轿憋拷锟斤拷锟斤拷
				_for(q, b, numBits - 1) bits[0][i][q][subID] = 1;
			}

			if (doubleReverse[1][i][j])
				b = bitsID[1][i][j];
			else
				b = bitsID[1][i][j] + 1; // 锟斤拷小锟斤拷锟斤拷要锟斤拷锟斤拷锟絙its锟斤拷锟斤拷锟絀D
			_for(k, 0, data[1][i][j].size())
			{ // 桶锟斤拷每锟斤拷锟斤拷锟斤拷
				subID = data[1][i][j][k].subID;
				_for(q, b, numBits - 1) bits[1][i][q][subID] = 1;
			}
		}
	}
	//cout << "HEM5DD Stop.\n";
}

// 锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷锟�?
void HEM5::match(const Pub& pub, int& matchSubs)
{
	// 锟街诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟�?
//	bitset<subs>* b = new bitset<subs>; // register
//	bitset<subs>* bLocal = new bitset<subs>;
//	vector<bool> attExist(numDimension, false);
//	int value, att, buck;
//
//	_for(i, 0, pub.size)
//	{
//		value = pub.pairs[i].value, att = pub.pairs[i].att, buck = value / buckStep;
//		attExist[att] = true;
//
//		if (doubleReverse[0][att][buck])
//		{
//			if (bitsID[0][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
//				*bLocal = fullBits[att];
//			else
//				*bLocal = bits[0][att][bitsID[0][att][buck]];
//			_for(j, endBucket[0][att][buck], buck + 1)
//				_for(k, 0, data[0][att][j].size())
//				(*bLocal)[data[0][att][j][k].subID] = 0;
//
//			_for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val <= value)
//					(*bLocal)[data[0][att][buck][k].subID] = 0;
//
//			*b = *b | *bLocal;
//		}
//		else
//		{
//			_for(j, buck + 1, endBucket[0][att][buck])
//				_for(k, 0, data[0][att][j].size())
//				(*b)[data[0][att][j][k].subID] = 1;
//
//			_for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val > value)
//					(*b)[data[0][att][buck][k].subID] = 1;
//
//			if (bitsID[0][att][buck] != -1)
//				*b = *b | bits[0][att][bitsID[0][att][buck]];
//		}
//
//		if (doubleReverse[1][att][buck])
//		{
//			if (bitsID[1][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
//				*bLocal = fullBits[att];
//			else
//				*bLocal = bits[1][att][bitsID[1][att][buck]];
//
//			_for(j, buck, endBucket[1][att][buck])
//				_for(k, 0, data[1][att][j].size())
//				(*bLocal)[data[1][att][j][k].subID] = 0;
//
//			_for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val >= value)
//					(*bLocal)[data[1][att][buck][k].subID] = 0;
//
//			*b = *b | *bLocal;
//		}
//		else
//		{
//			_for(j, endBucket[1][att][buck], buck)
//				_for(k, 0, data[1][att][j].size())
//				(*b)[data[1][att][j][k].subID] = 1;
//
//			_for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val < value)
//					(*b)[data[1][att][buck][k].subID] = 1;
//
//			if (bitsID[1][att][buck] != -1)
//				*b = *b | bits[1][att][bitsID[1][att][buck]]; // Bug: 锟斤拷att锟斤拷锟斤拷i
//		}
//	}
//	_for(i, 0, numDimension) if (!attExist[i])
//		*b = *b | fullBits[i];
//	matchSubs = numSub - b->count();

	// 锟街诧拷锟斤拷锟斤拷锟斤拷栈锟斤拷
	bitset<subs> b; // register
	bitset<subs> bLocal;
	vector<bool> attExist(numDimension, false);
	int value, att, buck;

	for (const auto& pp : pub.pairs)
	{
		value = pp.value, att = pp.att, buck = value / buckStep;
		attExist[att] = true;

		if (doubleReverse[0][att][buck])
		{
			if (bitsID[0][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
				bLocal = fullBits[att];
			else
				bLocal = bits[0][att][bitsID[0][att][buck]];
			_for(j, endBucket[0][att][buck], buck) _for(k, 0,
					data[0][att][j].size()) bLocal[data[0][att][j][k].subID] = 0;

			_for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val <= value)
					bLocal[data[0][att][buck][k].subID] = 0;

#if BlockSize == 64
            b |= bLocal;
#else
            Util::bitsetOr(b, bLocal);
#endif

		}
		else
		{
			_for(j,
				buck + 1, endBucket[0][att][buck]) _for(k, 0, data[0][att][j].size()) b[data[0][att][j][k].subID] = 1;

			_for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val > value)
					b[data[0][att][buck][k].subID] = 1;

			if (bitsID[0][att][buck] != -1)
#if BlockSize == 64
            b |= bits[0][att][bitsID[0][att][buck]];
#else
            Util::bitsetOr(b, bits[0][att][bitsID[0][att][buck]]);
#endif
		}

		if (doubleReverse[1][att][buck])
		{
			if (bitsID[1][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
				bLocal = fullBits[att];
			else
				bLocal = bits[1][att][bitsID[1][att][buck]];

			_for(j, buck + 1, endBucket[1][att][buck]) _for(k, 0,
					data[1][att][j].size()) bLocal[data[1][att][j][k].subID] = 0;

			_for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val >= value)
					bLocal[data[1][att][buck][k].subID] = 0;

#if BlockSize == 64
            b |= bLocal;
#else
            Util::bitsetOr(b, bLocal);
#endif
		}
		else
		{
			_for(j, endBucket[1][att][buck], buck) _for(k, 0, data[1][att][j].size()) b[data[1][att][j][k].subID] = 1;

			_for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val < value)
					b[data[1][att][buck][k].subID] = 1;

			if (bitsID[1][att][buck] != -1)
#if BlockSize == 64
            b |= bits[1][att][bitsID[1][att][buck]];
#else
            Util::bitsetOr(b, bits[1][att][bitsID[1][att][buck]]);
#endif
		}
	}

	/*if (numBits > 1)
	{*/
	_for(i, 0, numDimension) if (!attExist[i])
#if BlockSize == 64
            b |= fullBits[i];
#else
            Util::bitsetOr(b, fullBits[i]);
#endif

	/*}
	else
	{
		_for(i, 0, numDimension) if (!attExist[i])
			_for(j, 0, endBucket[0][i][0])
			_for(k, 0, data[0][i][j].size())
			b[data[0][i][j][k].subID] = 1;

		_for(i, 0, numDimension) if (!attExist[i])
			b = b | bits[0][i][0];
	}*/

	//_for(i, 0, subs) if (!b[i])
	//{
	//	++matchSubs;
	//	//cout << "HEM5 matches sub: " << i << endl;
	//}
	matchSubs = numSub - b.count();
}

// 锟斤拷锟斤拷时锟斤拷锟斤拷锟�?
void HEM5::match_debug(const Pub& pub, int& matchSubs)
{
	bitset<subs> b, bLocal;
	vector<bool> attExist(numDimension, false);
	int value, att, buck;

	_for(i, 0, pub.size)
	{
		Timer compareStart;
		value = pub.pairs[i].value, att = pub.pairs[i].att, buck = value / buckStep;
		attExist[att] = true;

		if (doubleReverse[0][att][buck])
		{
			Timer markStart;
			if (bitsID[0][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
				bLocal = fullBits[att];
			else
				bLocal = bits[0][att][bitsID[0][att][buck]];
			_for(j, endBucket[0][att][buck], buck) _for(k, 0,
					data[0][att][j].size()) bLocal[data[0][att][j][k].subID] = 0;
			markTime += (double)markStart.elapsed_nano();

			Timer compareStart;
			_for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val <= value)
					bLocal[data[0][att][buck][k].subID] = 0;
			compareTime += (double)compareStart.elapsed_nano();

			Timer orStart;
#if BlockSize == 64
            b |= bLocal;
#else
            Util::bitsetOr(b, bLocal);
#endif
			orTime += (double)orStart.elapsed_nano();
		}
		else
		{
			Timer markStart;
			_for(j, buck + 1, endBucket[0][att][buck]) _for(k, 0,
					data[0][att][j].size()) b[data[0][att][j][k].subID] = 1;
			markTime += (double)markStart.elapsed_nano();

			Timer compareStart;
			_for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val > value)
					b[data[0][att][buck][k].subID] = 1;
			compareTime += (double)compareStart.elapsed_nano();

			Timer orStart;
			if (bitsID[0][att][buck] != -1)
#if BlockSize == 64
            b |= bits[0][att][bitsID[0][att][buck]];
#else
            Util::bitsetOr(b, bits[0][att][bitsID[0][att][buck]]);
#endif
			orTime += (double)orStart.elapsed_nano();
		}

		if (doubleReverse[1][att][buck])
		{
			Timer markStart;
			if (bitsID[1][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
				bLocal = fullBits[att];
			else
				bLocal = bits[1][att][bitsID[1][att][buck]];
			_for(j, buck + 1, endBucket[1][att][buck]) _for(k, 0,
					data[1][att][j].size()) bLocal[data[1][att][j][k].subID] = 0;
			markTime += (double)markStart.elapsed_nano();

			Timer compareStart;
			_for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val >= value)
					bLocal[data[1][att][buck][k].subID] = 0;
			compareTime += (double)compareStart.elapsed_nano();

			Timer orStart;
#if BlockSize == 64
            b |= bLocal;
#else
            Util::bitsetOr(b, bLocal);
#endif
			orTime += (double)orStart.elapsed_nano();
		}
		else
		{
			Timer markStart;
			_for(j, endBucket[1][att][buck], buck) _for(k, 0, data[1][att][j].size()) b[data[1][att][j][k].subID] = 1;
			markTime += (double)markStart.elapsed_nano();

			Timer compareStart;
			_for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val < value)
					b[data[1][att][buck][k].subID] = 1;
			compareTime += (double)compareStart.elapsed_nano();

			Timer orStart;
			if (bitsID[1][att][buck] != -1)
#if BlockSize == 64
            b |= bits[1][att][bitsID[1][att][buck]];
#else
            Util::bitsetOr(b, bits[1][att][bitsID[1][att][buck]]);
#endif
			orTime += (double)orStart.elapsed_nano();
		}
	}

	//	if (numBits > 1) {
	Timer orStart;
	_for(i, 0, numDimension) if (!attExist[i])
#if BlockSize == 64
            b |= fullBits[i];
#else
            Util::bitsetOr(b, fullBits[i]);
#endif
	orTime += (double)orStart.elapsed_nano();
	//	} else {
	//		Timer markStart;
	//		_for(i, 0, numDimension) if (!attExist[i])
	//				_for(j, 0, endBucket[0][i][0]) _for(k, 0, data[0][i][j].size()) b[data[0][i][j][k].subID] = 1;
	//		markTime += (double) markStart.elapsed_nano();
	//
	//		Timer orStart;
	//		_for(i, 0, numDimension) if (!attExist[i])
	//				b = b | bits[0][i][0];
	//		orTime += (double) orStart.elapsed_nano();
	//	}

	Timer bitStart;
		_for(i, 0, subs) if (!b[i]) {
				++matchSubs;
				//cout << "HEM5 matches sub: " << i << endl;
			}
//	matchSubs = subs - b.count();
	bitTime += (double)bitStart.elapsed_nano();
}

void HEM5::match_parallel(const Pub& pub, int& matchSubs)
{
	vector<future<bitset<subs>>> threadResult;
	int seg = pub.size / parallelDegree;
	int remainder = pub.size % parallelDegree;
	int tId = 0, end;
	for (int begin = 0; begin < pub.size; begin = end, tId++)
	{
		if (tId < remainder)
			end = begin + seg + 1;
		else end = begin + seg;
		threadResult.emplace_back(threadPool.enqueue([this, &pub, begin, end]
		{
// 锟街诧拷锟斤拷锟斤拷锟斤拷栈锟斤拷
		  bitset<subs> b; // register
		  bitset<subs> bLocal;
		  for (int i = begin,value, att, buck; i < end; i++)
		  {
			  value = pub.pairs[i].value, att = pub.pairs[i].att, buck = value / buckStep;

			  if (doubleReverse[0][att][buck])
			  {
				  if (bitsID[0][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
					  bLocal = fullBits[att];
				  else
					  bLocal = bits[0][att][bitsID[0][att][buck]];
				  _for(j, endBucket[0][att][buck], buck) _for(k, 0,
						  data[0][att][j].size()) bLocal[data[0][att][j][k].subID] = 0;

				  _for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val <= value)
						  bLocal[data[0][att][buck][k].subID] = 0;

#if BlockSize == 64
            b |= bLocal;
#else
            Util::bitsetOr(b, bLocal);
#endif
			  }
			  else
			  {
				  _for(j, buck + 1, endBucket[0][att][buck]) _for(k, 0,
						  data[0][att][j].size()) b[data[0][att][j][k].subID] = 1;

				  _for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val > value)
						  b[data[0][att][buck][k].subID] = 1;

				  if (bitsID[0][att][buck] != -1)
#if BlockSize == 64
            		  b |= bits[0][att][bitsID[0][att][buck]];
#else
            		  Util::bitsetOr(b, bits[0][att][bitsID[0][att][buck]]);
#endif
			  }

			  if (doubleReverse[1][att][buck])
			  {
				  if (bitsID[1][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
					  bLocal = fullBits[att];
				  else
					  bLocal = bits[1][att][bitsID[1][att][buck]];

				  _for(j, buck + 1, endBucket[1][att][buck]) _for(k, 0,
						  data[1][att][j].size()) bLocal[data[1][att][j][k].subID] = 0;

				  _for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val >= value)
						  bLocal[data[1][att][buck][k].subID] = 0;

#if BlockSize == 64
            	  b |= bLocal;
#else
            	  Util::bitsetOr(b, bLocal);
#endif
			  }
			  else
			  {
				  _for(j, endBucket[1][att][buck], buck) _for(k, 0,
						  data[1][att][j].size()) b[data[1][att][j][k].subID] = 1;

				  _for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val < value)
						  b[data[1][att][buck][k].subID] = 1;

				  if (bitsID[1][att][buck] != -1)
#if BlockSize == 64
            		  b |= bits[1][att][bitsID[1][att][buck]];
#else
                      Util::bitsetOr(b, bits[1][att][bitsID[1][att][buck]]);
#endif
			  }
		  }
		  return b;
		}));
	}

	bitset<subs> gb;
	if (pub.size < atts)
	{
		vector<bool> attExist(numDimension, false);
		for (const auto item : pub.pairs)
			attExist[item.att] = true;

		/*if (numBits > 1)
	{*/
		_for(i, 0, numDimension) if (!attExist[i])
#if BlockSize == 64
            gb |= fullBits[i];
#else
            Util::bitsetOr(gb, fullBits[i]);
#endif
		/*}
		else
		{
			_for(i, 0, numDimension) if (!attExist[i])
				_for(j, 0, endBucket[0][i][0])
				_for(k, 0, data[0][i][j].size())
				b[data[0][i][j][k].subID] = 1;

			_for(i, 0, numDimension) if (!attExist[i])
				b = b | bits[0][i][0];
		}*/
	}

	// vector<bitset<subs>> threadResult2;
	// for (int i = 0; i < parallelDegree; i++)
	// 	threadResult2.emplace_back(threadResult[i].get());

#ifdef DEBUG // 锟斤拷锟节碉拷锟竭程归并锟斤拷锟斤拷锟矫伙拷锟�? 锟斤拷取锟斤拷锟斤拷锟竭程的诧拷锟街斤拷锟斤拷锟�? 锟脚匡拷始锟斤拷时锟斤拷锟酵会导锟铰诧拷锟斤拷平
	Timer mergeStart;
#endif

	// int pDi = (parallelDegree + 1) >> 1, pDn = parallelDegree;
	// while (pDn > 1) {
	// 	for (int i = 0; i < pDi; i++) {
	// 		if (i + pDi < pDn)
	// 			threadResult[i] = threadPool.enqueue([&, i](int j) {
	// 				return threadResult2[i] | threadResult2[j];
	// 			}, i + pDi);
	// 	}
	// 	for (int i = 0; i < pDi; i++) {
	// 		if (i + pDi < pDn)
	// 			threadResult2[i]=threadResult[i].get();
	// 	}
	// 	pDn = pDi;
	// 	pDi = (pDi + 1) >> 1;
	// }

	for (int i = 0; i < threadResult.size(); i++)
#if BlockSize == 64
            gb |= threadResult[i].get();
#else
            Util::bitsetOr(gb, threadResult[i].get());
#endif


	// for (int i = 0; i < threadResult2.size(); i++)
	// gb |= threadResult2[i];

#ifdef DEBUG
	mergeTime+=(double)mergeStart.elapsed_nano();
	Timer bitStart;
#endif

	// if (pub.size < atts) {
	// 	gb |= (threadResult2[0]);
	// 	matchSubs = numSub - gb.count();
	// } else {
	// 	matchSubs = numSub - threadResult2[0].count();
	// }
	matchSubs = numSub - gb.count();

#ifdef DEBUG
	bitTime += (double)bitStart.elapsed_nano();
#endif // DEBUG
}

void HEM5::match_avxOR_parallel(const Pub& pub, int& matchSubs)
{

	vector<future<bitset<subs>>> threadResult;
	int seg = pub.size / parallelDegree;
	int remainder = pub.size % parallelDegree;
	int tId = 0, end;
	for (int begin = 0; begin < pub.size; begin = end, tId++)
	{
		if (tId < remainder)
			end = begin + seg + 1;
		else end = begin + seg;
		threadResult.emplace_back(threadPool.enqueue([this, &pub, begin, end]
		{
		  bitset<subs> b; // register
		  bitset<subs> bLocal;
		  int value, att, buck;
		  for (int i = begin; i < end; i++)
		  {
			  value = pub.pairs[i].value, att = pub.pairs[i].att, buck = value / buckStep;

			  if (doubleReverse[0][att][buck])
			  {
				  if (bitsID[0][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
					  bLocal = fullBits[att];
				  else
					  bLocal = bits[0][att][bitsID[0][att][buck]];
				  _for(j, endBucket[0][att][buck], buck) for (auto&& iCob : data[0][att][j])
						  bLocal[iCob.subID] = 0;
				  _for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val <= value)
						  bLocal[data[0][att][buck][k].subID] = 0;
#if BlockSize == 64
            	  b |= bLocal;
#else
            	  Util::bitsetOr(b, bLocal);
#endif
			  }
			  else
			  {
				  _for(j, buck + 1, endBucket[0][att][buck]) for (auto&& iCob : data[0][att][j])
						  b[iCob.subID] = 1;
				  _for(k, 0, data[0][att][buck].size()) if (data[0][att][buck][k].val > value)
						  b[data[0][att][buck][k].subID] = 1;
//				  if (bitsID[0][att][buck] != -1)
//					  Util::bitsetOr(b, bits[0][att][bitsID[0][att][buck]]);//b = b | bits[0][att][bitsID[0][att][buck]];
#if BlockSize == 64
            	  b |= bits[0][att][bitsID[0][att][buck]];
#else
            	  Util::bitsetOr(b, bits[0][att][bitsID[0][att][buck]]);
#endif
			  }

			  if (doubleReverse[1][att][buck])
			  {
				  if (bitsID[1][att][buck] == numBits - 1) // 只锟斤拷1锟斤拷bitset时锟斤拷锟斤拷fullBits锟较ｏ拷去锟斤拷: && numBits > 1
					  bLocal = fullBits[att];
				  else
					  bLocal = bits[1][att][bitsID[1][att][buck]];
				  _for(j, buck + 1, endBucket[1][att][buck]) for (auto&& iCob : data[1][att][j])
						  bLocal[iCob.subID] = 0;
				  _for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val >= value)
						  bLocal[data[1][att][buck][k].subID] = 0;
#if BlockSize == 64
            	  b |= bLocal;
#else
            	  Util::bitsetOr(b, bLocal);
#endif
			  }
			  else
			  {
				  _for(j, endBucket[1][att][buck], buck) for (auto&& iCob : data[1][att][j])
						  b[iCob.subID] = 1;
				  _for(k, 0, data[1][att][buck].size()) if (data[1][att][buck][k].val < value)
						  b[data[1][att][buck][k].subID] = 1;
//				  if (bitsID[1][att][buck] != -1)
//					  Util::bitsetOr(b, bits[1][att][bitsID[1][att][buck]]);//b = b | bits[1][att][bitsID[1][att][buck]]; // Bug: 锟斤拷att锟斤拷锟斤拷i
#if BlockSize == 64
            	  b |= bits[1][att][bitsID[1][att][buck]];
#else
            	  Util::bitsetOr(b, bits[1][att][bitsID[1][att][buck]]);
#endif
			  }
		  }
		  return b;
		}));
	}

	bitset<subs> gb;
	if (pub.size < atts)
	{
		vector<bool> attExist(numDimension, false);
		for (const auto item : pub.pairs)
			attExist[item.att] = true;

		/*if (numBits > 1)
	{*/
		_for(i, 0, numDimension) if (!attExist[i])
#if BlockSize == 64
            gb |= fullBits[i];
#else
            Util::bitsetOr(gb, fullBits[i]);
#endif
		/*}
		else
		{
			_for(i, 0, numDimension) if (!attExist[i])
				_for(j, 0, endBucket[0][i][0])
				_for(k, 0, data[0][i][j].size())
				b[data[0][i][j][k].subID] = 1;

			_for(i, 0, numDimension) if (!attExist[i])
				b = b | bits[0][i][0];
		}*/
	}

#ifdef DEBUG
	Timer mergeStart;
#endif
	for (int i = 0; i < threadResult.size(); i++)
	{
#if BlockSize == 64
        gb |= threadResult[i].get();
#else
        Util::bitsetOr(gb, threadResult[i].get());
#endif
    }
#ifdef DEBUG
	mergeTime+=(double)mergeStart.elapsed_nano();
	Timer bitStart;
#endif
	matchSubs = numSub - gb.count();
#ifdef DEBUG
	bitTime += (double)bitStart.elapsed_nano();
#endif // DEBUG
} // match_avxOR_parallel

//void HEM5::calBucketSize() {
//	bucketSub.clear();
//	bucketSub.resize(numBucket);
//	_for(i, 0, numDimension)
//		_for(j, 0, numBucket)
//		{
//			_for(k, 0, data[0][i][j].size())
//				bucketSub[j].insert(data[0][i][j][k].subID);
//			_for(k, 0, data[1][i][j].size())
//				bucketSub[j].insert(data[1][i][j][k].subID);
//		}
//}

int HEM5::calMemory()
{
	long long size = 0; // Byte
	size += sizeof(bits) + sizeof(bits[0]) * 2 + sizeof(data) + sizeof(data[0]) + sizeof(data[1]);
	//cout << sizeof(bits[0]) << " " << sizeof(bits[1]) <<" " << sizeof(data) << " " << sizeof(data[0]) << " " << sizeof(data[1]) << "\n";
	_for(i, 0, numDimension)
	{
		// 锟斤拷每锟斤拷维锟斤拷锟斤拷bits锟斤拷锟斤拷锟斤拷锟揭伙拷锟斤拷锟斤拷锟�? 2*sizeof(bitset<subs>)*numDimension*numBits
		size += sizeof(bitset<subs>) * (bits[0][i].size() + bits[1][i].size());
		size += (sizeof(bits[0][i]) + sizeof(data[0][i])) * 2;
		//cout << i << ": " << sizeof(bits[0][i]) << " " << sizeof(data[0][i]) << " ";
		_for(j, 0, numBucket)
		{
			//cout << sizeof(data[0][i][j]) << " " << sizeof(data[1][i][j]) << " ";
			size += sizeof(data[0][i][j]) + sizeof(data[1][i][j]);
			size += sizeof(Combo) * (data[0][i][j].size() + data[1][i][j].size());
		}
		//cout << "\n";
	}

	// fullBits
	if (numBits > 1)
	{
		size += sizeof(bitset<subs>) * fullBits.size(); // fullBits.size()锟斤拷numDimension
		size += sizeof(fullBits); // 24
		//cout << "fullBits: " << sizeof(fullBits) << " " << sizeof(fullBits[0]) << "\n";
	}

	// 锟斤拷锟斤拷fix
	//cout << "fix: " << sizeof(fix) << " " << sizeof(fix[0]) << " " << sizeof(fix[0][10]) << sizeof(fix[1][7][20]) << "\n";
	size += sizeof(fix) + sizeof(fix[0]) * 2 + sizeof(fix[0][0]) * numDimension +
			sizeof(fix[0][0][0]) * numDimension * (numBucket + 1) * 2;

	// 锟斤拷锟斤拷endBucket锟斤拷锟斤拷锟斤拷bitsID锟斤拷锟斤拷锟斤拷doubleReverse
	size += (4 * sizeof(int) + 2 * sizeof(bool)) * numDimension * numBucket;
	size += sizeof(endBucket[0]) * 4 + sizeof(endBucket[0][0]) * numDimension * 4;
	//cout << sizeof(endBucket) << " " << sizeof(endBucket[0]) << " " << sizeof(endBucket[0][0]) << " " << sizeof(endBucket[0][0][0]) << "\n";
	size = size / 1024 / 1024; // MB
	return (int)size;
}

void HEM5::printRelation(int dimension_i)
{
	cout << "\n\nHEM5DDMap\n";
	if (dimension_i == -1)
		_for(i, 0, numDimension)
		{
			cout << "\nDimension " << i << "    LowBucket Predicates: " << fix[0][i][0] << "   ----------------\n";
			_for(j, 0, numBucket)
			{
				cout << "lBkt" << j << ": bID=" << bitsID[0][i][j] << ", eBkt=" << endBucket[0][i][j] << ", dRvs="
					 << doubleReverse[0][i][j] << "; ";
				if (j % 5 == 0 && j > 0)
					cout << "\n";
			}
			cout << "\n\nDimension " << i << "    HighBucket Predicates: " << fix[1][i][numBucket]
				 << "   ----------------\n";
			_for(j, 0, numBucket)
			{
				cout << "hBkt" << j << ": bID=" << bitsID[1][i][j] << ", eBkt=" << endBucket[1][i][j] << ", dRvs="
					 << doubleReverse[1][i][j] << "; ";
				if (j % 5 == 0 && j > 0)
					cout << "\n";
			}
		}
	else
	{
		cout << "\nDimension: " << dimension_i << "    LowBucket Predicates: " << fix[0][dimension_i][0]
			 << "   ----------------\n";
		_for(i, 0, numBucket)
		{
			cout << "lBkt" << i << ": bID=" << bitsID[0][dimension_i][i] << ", eBkt=" << endBucket[0][dimension_i][i]
				 << ", dRvs=" << doubleReverse[0][dimension_i][i] << "; ";
			if (i % 5 == 0 && i > 0)
				cout << "\n";
		}
		cout << "\n\nDimension: " << dimension_i << "    HighBucket Predicates: " << fix[1][dimension_i][numBucket]
			 << "   ----------------\n";
		_for(i, 0, numBucket)
		{
			cout << "hBkt" << i << ": bID=" << bitsID[1][dimension_i][i] << ", eBkt=" << endBucket[1][dimension_i][i]
				 << ", dRvs=" << doubleReverse[1][dimension_i][i] << "; ";
			if (i % 5 == 0 && i > 0)
				cout << "\n";
		}
	}
	cout << "\n\n";
}

vector<int> HEM5::calMarkNumForBuckets()
{
	vector<int> numMarking(numBucket, 0);
	_for(i, 0, numDimension)
	{
		_for(j, 0, numBucket)
		{
			numMarking[j] += data[0][i][j].size() + data[1][i][j].size(); // 锟饺斤拷

			if (doubleReverse[0][i][j])
			{
				_for(k, endBucket[0][i][j], j) numMarking[j] += data[0][i][k].size();
			}
			else
			{
				_for(k, j+1, endBucket[0][i][j]) numMarking[j] += data[0][i][k].size();
			}

			if (doubleReverse[1][i][j])
			{
				_for(k, j+1, endBucket[1][i][j]) numMarking[j] += data[1][i][k].size(); // Bug: not 0 but 1.
			}
			else
			{
				_for(k, endBucket[1][i][j], j) numMarking[j] += data[1][i][k].size();
			}
		}
	}
	return numMarking;
}