简单之特征检测缓存设计

    在开发中，很多人都在为效率，精确与安全方面做最大的平衡，但结果往往不如人意，没有完美的解决方案，只有针对性的对象与方法，不同的方向有不同的需要，过于追求完美最终受伤的还是自己。想做一个高效但精确度较低的简单特征检测设计，感觉到了利弊的矛盾，但凡是都值得一试！

#define MAX_CHATIC_SIZE (256)

//单个缓存方案
typedef struct _BUNCH_CACHE {
bool bOwn;
bool bPUnit[MAX_CHATIC_SIZE];
} BUNCH_CACHE,*PBUNCH_CACHE;

typedef struct _CHARACTERISTIC_CACHE {
bool bOwn;
BUNCH_CACHE sBCache[MAX_CHATIC_SIZE];
} CHARACTERISTIC_CACHE, *PCHARACTERISTIC_CACHE;

//多个缓存方案
typedef struct _GROUP_CHARACTERISTIC_CACHE {
CHARACTERISTIC_CACHE sCCache[MAX_CHATIC_SIZE];
} GROUP_CHARACTERISTIC_CACHE, *PGROUP_CHARACTERISTIC_CACHE;

/*
* 通过云计算统计出目前最流行的特征数据,特征数据最大长度为256个字节;
* 缓存支持65536个特征数据,虽然精确率较低但同时也有提高精确降低效率的方法;
*/

//初始化准备;
inline PCHARACTERISTIC_CACHE _cdecl ChaticCache_Init(void)
{
PCHARACTERISTIC_CACHE lpChaticCache = (PCHARACTERISTIC_CACHE)malloc((sizeof(CHARACTERISTIC_CACHE) * MAX_CHATIC_SIZE));

if (NULL == lpChaticCache)
return NULL;

memset(lpChaticCache, 0, (sizeof(CHARACTERISTIC_CACHE) * MAX_CHATIC_SIZE));

return (lpChaticCache);
}

inline void _cdecl ChaticCache_Free(PCHARACTERISTIC_CACHE * lpChaticCache)
{
if (*lpChaticCache != NULL)
{
free(*lpChaticCache);
*lpChaticCache = NULL;
}
}

enum _CHATIC_CACHE_RETURN {
Error_Succeed,
Error_Param,
Error_Fail
};

//充填缓存特征数据;
inline int _cdecl ChaticCache_Fill(PCHARACTERISTIC_CACHE lpChaticCache, const UCHAR * lpFillData, size_t uCount)
{
register USHORT uByteIndex = 0U;
register UCHAR uLByteIndex = 0U;

if (NULL == lpChaticCache || NULL == lpFillData || uCount > MAX_CHATIC_SIZE)
return Error_Param;

uLByteIndex = *lpFillData;

if (!(lpChaticCache[*lpFillData].bOwn))
lpChaticCache[*lpFillData].bOwn = true;

for (uByteIndex += 1U; uByteIndex < uCount; ++uByteIndex)
{
if (!(lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bOwn))
lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bOwn = true;
if (!(lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bPUnit[uLByteIndex]))
lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bPUnit[uLByteIndex] = true;
uLByteIndex = lpFillData[uByteIndex];
}
return Error_Succeed;
}

//比较缓存特征数据;
inline int _cdecl ChaticCache_Cmps(PCHARACTERISTIC_CACHE lpChaticCache, const UCHAR * lpCmpsData, size_t uCount)
{
register USHORT uByteIndex = 0U;
register UCHAR uLByteIndex = 0U;

UCHAR uExcluData[MAX_CHATIC_SIZE] = { 0U };
const size_t uMinChaticCodeSize = uCount / sizeof(DWORD); //提高精确性,对抗外部干扰[特征码重复数据量较少,作为一种规范];

if (NULL == lpChaticCache || NULL == lpCmpsData || uCount > MAX_CHATIC_SIZE)
return Error_Param;

if (!(lpChaticCache[*lpCmpsData].bOwn))
return Error_Fail;
else
uLByteIndex = *lpCmpsData;

for (uByteIndex += 1U; uByteIndex < uCount; ++uByteIndex)
{
if ((++uExcluData[uLByteIndex]) > uMinChaticCodeSize)
return Error_Fail;
else if (!(lpChaticCache[*lpCmpsData].sBCache[lpCmpsData[uByteIndex]].bOwn))
return Error_Fail;
else if (!(lpChaticCache[*lpCmpsData].sBCache[lpCmpsData[uByteIndex]].bPUnit[uLByteIndex]))
return Error_Fail;
else
uLByteIndex = lpCmpsData[uByteIndex];
}
return Error_Succeed;
}