sphinx 源码阅读之数据结构与算法

最新推荐文章于 2023-10-14 14:22:53 发布
最新推荐文章于 2023-10-14 14:22:53 发布
阅读量909 收藏 1
点赞数
分类专栏： 搜索引擎

源码在 sphinx 官网上就可以下载到.
起初我下载的是最新版本，结果由于代码大约有 10W 行，我看了快 1W 行后发现这样看也不是个办法。
于是我想着生成一个项目关系图来阅读代码，但是我这电脑只有windows, 网上介绍的大多都是 linux 上的，于是我只好取消这个念头。
后来，我想我看sphinx源码主要是先弄明白 sphinx 的工作原理，而工作原理应该一直都是保持不变的，于是我就去下载第一个版本。
第一个版本果然给力，只有 1W 行，于是我就开始高高兴兴的开始从 main 函数开始看源代码了。
看了不就发现 sphinx 用了很多数据结构，而且是自己等装好的，还是先把这些数据结构弄明白了比较好。
于是就有了这篇文章。
为了方便读者阅读，这些数据结构和算法就从简单的慢慢罗列出来。

大家可以看右面的目录，然后去看自己感兴趣的数据结构或算法对应的小节。
如果对那个小节有疑问，可以随时留言。

sphinx 把最值封装成了一个宏。

  
  
  1. #define Min(a,b)			((a)<(b)?(a):(b))
  2. #define Max(a,b)			((a)>(b)?(a):(b))

为了这个通用，使用了基本的模板函数。
而交换则使用第三个缓存变量来实现这个功能。

  
  
  1. template<typename T> 
  2. inline void Swap(T & v1, T & v2) {
  3.     T temp = v1;
  4.     v1 = v2;
  5.     v2 = temp;
  6. }

这个 vector 实现的功能很简单，基本的 insert，remove，get, set 等操作。
只是附加了一个排序功能。
具体实现方式这里就不多说了，这些都是一个类基本的操作，都很容易实现(需要谁需要这个vector的实现讲解，可以留言)。

  
  
  1. template<typename T, int INITIAL_LIMIT = 1024> 
  2. class CSphVector {
  3.     public:
  4.         CSphVector(); //初始化向量
  5.         ~CSphVector(); //回收向量
  6.         T & Add(); //增加一个元素，返回这个元素的引用
  7.         void Add(const T & tValue);//增加一个元素
  8.         T & Last();//得到最后一个元素
  9.         void Remove(int iIndex);//删除指定位置的元素
  10.         void Grow(int iNewLimit);//扩大缓存的大小，两倍两倍的增长
  11.         void Resize(int iNewLength);// 原先设置数组的大小
  12.         void Reset();// 重置数组
  13.         int GetLength();//得到数组的长度
  14.         void Sort(int iStart = 0, int iEnd = -1);// 正常排序
  15.         void RSort(int iStart = 0, int iEnd = -1);// 逆序
  16.         const T & operator [](int iIndex) const;// 读指定位置的值
  17.         T & operator [](int iIndex);// 设置指定位置的值
  18.     private:
  19.         int m_iLength;//数组大小
  20.         int m_iLimit;//数组缓存大小
  21.         T * m_pData;//数组
  22. };

这次 sphinx 自己实现的 string 类的功能就比较多了。
这里我罗列出一些比较简单的功能。

  
  
  1. struct CSphString{
  2. 	CSphString (); //构造
  3.     CSphString ( const char * sString );
  4. 	CSphString ( const CSphString & rhs ); 
  5.     CSphString ( const char * sValue, int iLen );
  6. 	~CSphString (); //析构
  7. 	const char * cstr () const; //得到字符串
  8. 	const char * scstr() const;//得到字符串，默认未空串
  9. 

  10. 	inline bool operator == ( const char * t ) const; //判断两个串是否相等
  11. 	inline bool operator == ( const CSphString & t ) const;
  12. 	inline bool operator != ( const CSphString & t ) const;
  13. 	bool operator != ( const char * t ) const;
  14. 

  15. 	
  16. 	const CSphString & operator = ( const CSphString & rhs );
  17. 	CSphString SubString ( int iStart, int iCount ) const;
  18. 

  19. 	bool IsEmpty () const;
  20. 	CSphString & ToLower ();
  21. 	CSphString & ToUpper ();
  22. 	int Length () const;
  23. 	bool operator < ( const CSphString & b );
  24. };

判断一个字符是不是自己想要的字符。

  
  
  1. inline int sphIsAlpha ( int c ){
  2. 	return ( c>='0' && c<='9' ) || ( c>='a' && c<='z' ) || ( c>='A' && c<='Z' ) || c=='-' || c=='_';
  3. }

判断一个字符是不是空白

  
  
  1. inline bool sphIsSpace ( int iCode ){
  2. 	return iCode==' ' || iCode=='\t' || iCode=='\n' || iCode=='\r';
  3. }

字符串 trim 这个功能很常用，取出前边和后边的空白。

  
  
  1. static char * ltrim ( char * sLine ){
  2. 	while ( *sLine && isspace(*sLine) )
  3. 		sLine++;
  4. 	return sLine;
  5. }
  6. static char * rtrim ( char * sLine ){
  7. 	char * p = sLine + strlen(sLine) - 1;
  8. 	while ( p>=sLine && isspace(*p) )
  9. 		p--;
  10. 	p[1] = '\0';
  11. 	return sLine;
  12. }
  13. static char * trim ( char * sLine ){
  14. 	return ltrim ( rtrim ( sLine ) );
  15. }

切割字符串也是很常用的函数。
一般需要指定分隔符，默认分隔符是空白。
具体的实现代码这里就不展示了。

  
  
  1. void sphSplit ( CSphVector<CSphString> & dOut, const char * sIn, const char * sBounds ){
  2. 	if ( !sIn )return;
  3. 

  4. 	const char * p = (char*)sIn;
  5. 	while ( *p ){
  6. 		// skip until the first non-boundary character
  7. 		const char * sNext = p;
  8. 		while ( *p && !strchr ( sBounds, *p ) )p++;
  9. 

  10. 		// add the token, skip the char
  11. 		dOut.Add().SetBinary ( sNext, p-sNext );
  12. 		p++;
  13. 	}
  14. }
  15.

正则表达式大家都用过吧，这次 sphinx 实现了一个简单的正则表达式检验函数。
主要用于检验一个字符串是否符合指定的格式。

  
  
  1. bool sphWildcardMatch ( const char * sString, const char * sPattern ){
  2. 	if ( !sString || !sPattern )return false;
  3. 

  4. 	const char * s = sString;
  5. 	const char * p = sPattern;
  6. 	while ( *s ){
  7. 		switch ( *p ){
  8. 		case '\\':
  9. 			// escaped char, strict match the next one literally
  10. 			p++;
  11. 			if ( *s++!=*p++ )return false;
  12. 			break;
  13. 		case '?':
  14. 			// match any character
  15. 			s++;
  16. 			p++;
  17. 			break;
  18. 		case '%':
  19. 			// gotta match either 0 or 1 characters
  20. 			// well, lets look ahead and see what we need to match next
  21. 			p++;
  22. 

  23. 			// just a shortcut, %* can be folded to just *
  24. 			if ( *p=='*' )break;
  25. 

  26. 			// plain char after a hash? check the non-ambiguous cases
  27. 			if ( !sphIsWild(*p) ){
  28. 				if ( s[0]!=*p ){
  29. 					// hash does not match 0 chars
  30. 					// check if we can match 1 char, or it's a no-match
  31. 					if ( s[1]!=*p )return false;
  32. 					s++;
  33. 					break;
  34. 				} else{
  35. 					// hash matches 0 chars
  36. 					// check if we could ambiguously match 1 char too, though
  37. 					if ( s[1]!=*p )break;
  38. 					// well, fall through to "scan both options" route
  39. 				}
  40. 			}
  41. 

  42. 			// could not decide yet
  43. 			// so just recurse both options
  44. 			if ( sphWildcardMatch ( s, p ) )return true;
  45. 			if ( sphWildcardMatch ( s+1, p ) )return true;
  46. 			return false;
  47. 		case '*':
  48. 			// skip all the extra stars and question marks
  49. 			for ( p++; *p=='*' || *p=='?'; p++ )
  50. 				if ( *p=='?' ){
  51. 					s++;
  52. 					if ( !*s )return p[1]=='\0';
  53. 				}
  54. 

  55. 				// short-circuit trailing star
  56. 				if ( !*p )return true;
  57. 

  58. 				// so our wildcard expects a real character
  59. 				// scan forward for its occurrences and recurse
  60. 				for ( ;; ){
  61. 					if ( !*s )return false;
  62. 					if ( *s==*p && sphWildcardMatch ( s+1, p+1 ) )return true;
  63. 					s++;
  64. 				}
  65. 				break;
  66. 		default:
  67. 			// default case, strict match
  68. 			if ( *s++!=*p++ )return false;
  69. 			break;
  70. 		}
  71. 	}
  72. 

  73. 	// string done
  74. 	// pattern should be either done too, or a trailing star, or a trailing hash
  75. 	return p[0]=='\0'|| ( p[0]=='*' && p[1]=='\0' )|| ( p[0]=='%' && p[1]=='\0' );
  76. }

做项目的时候经常会遇到一些打日志的库，其实这个功能很简单。
基本原理都是使用和 printf 类似的方法: 变参。

  
  
  1. static void StdoutLogger ( ESphLogLevel eLevel, const char * sFmt, va_list ap ){
  2. 	switch ( eLevel ){
  3.         case SPH_LOG_FATAL: fprintf ( stdout, "FATAL: " ); break;
  4.         case SPH_LOG_WARNING: fprintf ( stdout, "WARNING: " ); break;
  5.         case SPH_LOG_INFO: fprintf ( stdout, "WARNING: " ); break;
  6.         case SPH_LOG_DEBUG:  fprintf ( stdout, "DEBUG: " ); break;
  7. 	}
  8. 	vfprintf ( stdout, sFmt, ap );
  9. 	fprintf ( stdout, "\n" );
  10. }
  11. static SphLogger_fn g_pLogger = &StdoutLogger;
  12. 

  13. inline void Log ( ESphLogLevel eLevel, const char * sFmt, va_list ap ){
  14. 	if ( !g_pLogger ) return;
  15. 	( *g_pLogger ) ( eLevel, sFmt, ap );
  16. }
  17. 

  18. 

  19. void sphWarning ( const char * sFmt, ... ){
  20. 	va_list ap;
  21. 	va_start ( ap, sFmt );
  22. 	Log ( SPH_LOG_WARNING, sFmt, ap );
  23. 	va_end ( ap );
  24. }
  25. void sphInfo ( const char * sFmt, ... );
  26. void sphLogFatal ( const char * sFmt, ... );
  27. void sphLogDebug ( const char * sFmt, ... );

上面的日志系统，最后还是调用了 vfprintf 函数， 没有让我们看到变参到底怎么实现的。
但是 sphinx 自己实现了一个 sphVSprintf 函数，和 vfprintf 类似，我不明白那个日志系统为什么不用自己的这个输出函数。
由于是对字符串分析，可以理解为一个简单的自动机。
遇到什么字符，期望下个字符是什么。
这里就不多说这个自动机了。

  
  
  1. static int sphVSprintf ( char * pOutput, const char * sFmt, va_list ap ){
  2. 	enum eStates { SNORMAL, SPERCENT, SHAVEFILL, SINWIDTH, SINPREC };
  3. 	eStates state = SNORMAL;
  4. 	int iPrec = 0;
  5. 	int iWidth = 0;
  6. 	char cFill = ' ';
  7. 	const char * pBegin = pOutput;
  8. 	bool bHeadingSpace = true;
  9. 

  10. 	char c;
  11. 	while ( ( c = *sFmt++ )!=0 ){
  12. 		// handle percent
  13. 		if ( c=='%' ){
  14. 			if ( state==SNORMAL ){
  15. 				state = SPERCENT;
  16. 				iPrec = 0;
  17. 				iWidth = 0;
  18. 				cFill = ' ';
  19. 			} else{
  20. 				state = SNORMAL;
  21. 				*pOutput++ = c;
  22. 			}
  23. 			continue;
  24. 		}
  25. 

  26. 		// handle regular chars
  27. 		if ( state==SNORMAL ){
  28. 			*pOutput++ = c;
  29. 			continue;
  30. 		}
  31. 

  32. 		// handle modifiers
  33. 		switch ( c ){
  34.             case '0':
  35.                 if ( state==SPERCENT ){
  36.                     cFill = '0';
  37.                     state = SHAVEFILL;
  38.                     break;
  39.                 }
  40.             case '1': case '2': case '3':
  41.             case '4': case '5': case '6':
  42.             case '7': case '8': case '9':
  43.                 if ( state==SPERCENT || state==SHAVEFILL )
  44.                 {
  45.                     state = SINWIDTH;
  46.                     iWidth = c - '0';
  47.                 } else if ( state==SINWIDTH )
  48.                     iWidth = iWidth * 10 + c - '0';
  49.                 else if ( state==SINPREC )
  50.                     iPrec = iPrec * 10 + c - '0';
  51.                 break;
  52. 

  53.             case '-':
  54.                 if ( state==SPERCENT )
  55.                     bHeadingSpace = false;
  56.                 else
  57.                     state = SNORMAL; // FIXME? means that bad/unhandled syntax with dash will be just ignored
  58.                 break;
  59. 

  60.             case '.':
  61.                 state = SINPREC;
  62.                 iPrec = 0;
  63.                 break;
  64. 

  65.             case 's': // string
  66.                 {
  67.                     const char * pValue = va_arg ( ap, const char * );
  68.                     if ( !pValue )
  69.                         pValue = "(null)";
  70.                     int iValue = strlen ( pValue );
  71. 

  72.                     if ( iWidth && bHeadingSpace )
  73.                         while ( iValue < iWidth-- )
  74.                             *pOutput++ = ' ';
  75. 

  76.                     if ( iPrec && iPrec < iValue )
  77.                         while ( iPrec-- )
  78.                             *pOutput++ = *pValue++;
  79.                     else
  80.                         while ( *pValue )
  81.                             *pOutput++ = *pValue++;
  82. 

  83.                     if ( iWidth && !bHeadingSpace )
  84.                         while ( iValue < iWidth-- )
  85.                             *pOutput++ = ' ';
  86. 

  87.                     state = SNORMAL;
  88.                     break;
  89.                 }
  90. 

  91.             case 'p': // pointer
  92.                 {
  93.                     void * pValue = va_arg ( ap, void * );
  94.                     uint64_t uValue = uint64_t ( pValue );
  95.                     UItoA ( &pOutput, uValue, 16, iWidth, iPrec, cFill );
  96.                     state = SNORMAL;
  97.                     break;
  98.                 }
  99. 

  100.             case 'x': // hex integer
  101.             case 'd': // decimal integer
  102.                 {
  103.                     DWORD uValue = va_arg ( ap, DWORD );
  104.                     UItoA ( &pOutput, uValue, ( c=='x' ) ? 16 : 10, iWidth, iPrec, cFill );
  105.                     state = SNORMAL;
  106.                     break;
  107.                 }
  108. 

  109.             case 'l': // decimal int64
  110.                 {
  111.                     int64_t iValue = va_arg ( ap, int64_t );
  112.                     UItoA ( &pOutput, iValue, 10, iWidth, iPrec, cFill );
  113.                     state = SNORMAL;
  114.                     break;
  115.                 }
  116. 

  117.             default:
  118.                 state = SNORMAL;
  119.                 *pOutput++ = c;
  120. 		}
  121. 	}
  122. 

  123. 	// final zero to EOL
  124. 	*pOutput++ = '\n';
  125. 	return pOutput - pBegin;
  126. }

之前我曾写过一篇文章详解二进制数中1的个数,大家可以看看。

  
  
  1. inline int sphBitCount ( DWORD n ){
  2. 	register DWORD tmp;
  3. 	tmp = n - ((n >> 1) & 033333333333) - ((n >> 2) & 011111111111);
  4. 	return ( (tmp + (tmp >> 3) ) & 030707070707) % 63;
  5. }
  
  
  1. /// how much bits do we need for given int
  2. inline int sphLog2 ( uint64_t uValue )
  3. {
  4. #if USE_WINDOWS
  5. 	DWORD uRes;
  6. 	if ( BitScanReverse ( &uRes, (DWORD)( uValue>>32 ) ) )
  7. 		return 33+uRes;
  8. 	BitScanReverse ( &uRes, DWORD(uValue) );
  9. 	return 1+uRes;
  10. #elif __GNUC__ || __clang__
  11. 	if ( !uValue )
  12. 		return 0;
  13. 	return 64 - __builtin_clzl(uValue);
  14. #else
  15. 	int iBits = 0;
  16. 	while ( uValue )
  17. 	{
  18. 		uValue >>= 1;
  19. 		iBits++;
  20. 	}
  21. 	return iBits;
  22. #endif
  23. }

这个堆排序写的太奇葩了，哎，不能说什么了。

  
  
  1. /// generic accessor
  2. template < typename T > struct SphAccessor_T{
  3. 	T & Key ( T * a ) const; //得到指针的值
  4. 	void CopyKey ( T * pMed, T * pVal ) const;
  5. 	void Swap ( T * a, T * b ) const;
  6. 	T * Add ( T * p, int i ) const;//第i个位置的指针
  7. 	int Sub ( T * b, T * a ) const;//指针偏移量
  8. };
  9. 

  10. 

  11. /// heap sort helper
  12. // 自底向上进行堆排序
  13. //pData 带排序数组
  14. //iStart 开始位置
  15. //iEnd 结束位置
  16. //COMP 比较函数
  17. //ACC 访问指针的类
  18. template < typename T, typename U, typename V >
  19. void sphSiftDown ( T * pData, int iStart, int iEnd, U COMP, V ACC ){
  20. 	for ( ;; ){
  21. 		int iChild = iStart*2+1;
  22. 		if ( iChild>iEnd )return;
  23. 

  24. 		int iChild1 = iChild+1;
  25. 		if ( iChild1<=iEnd && COMP.IsLess ( ACC.Key ( ACC.Add ( pData, iChild ) ), ACC.Key ( ACC.Add ( pData, iChild1 ) ) ) )
  26. 			iChild = iChild1;
  27. 

  28. 		if ( COMP.IsLess ( ACC.Key ( ACC.Add ( pData, iChild ) ), ACC.Key ( ACC.Add ( pData, iStart ) ) ) )
  29. 			return;
  30. 		ACC.Swap ( ACC.Add ( pData, iChild ), ACC.Add ( pData, iStart ) );
  31. 		iStart = iChild;
  32. 	}
  33. }
  34. 

  35. 

  36. /// heap sort
  37. //奇葩的是先求出最大堆，然后反转，还边反转边维护堆。  
  38. //最终是个最小堆。  
  39. template < typename T, typename U, typename V >
  40. void sphHeapSort ( T * pData, int iCount, U COMP, V ACC ){
  41. 	if ( !pData || iCount<=1 )
  42. 		return;
  43. 

  44. 	// build a max-heap, so that the largest element is root
  45. 	for ( int iStart=( iCount-2 )>>1; iStart>=0; iStart-- )
  46. 		sphSiftDown ( pData, iStart, iCount-1, COMP, ACC );
  47. 

  48. 	// now keep popping root into the end of array
  49. 	for ( int iEnd=iCount-1; iEnd>0; ){
  50. 		ACC.Swap ( pData, ACC.Add ( pData, iEnd ) );
  51. 		sphSiftDown ( pData, 0, --iEnd, COMP, ACC );
  52. 	}
  53. }

sphinx 的快速排序也很奇葩。
一般的快速排序是递归，sphinx使用栈模拟递归。
这样栈的大小大概就是 log(n) 了。
而且栈为空的时候共有 log(n) 次。
当数据特殊的时候，快排会退化为 n\^2 的复杂度，这个时候，栈为空的几率变大了。
于是 sphinx 加了个修复， 当栈为空的次数大于 2.5 * log(n)， 就是用上面那个奇葩的堆排序。
不过这个优化作用不大。

另外这个快排加了一个小优化：当需要排序的数量小于32时，使用插入排序。

  
  
  1. template < typename T, typename U, typename V >
  2. void sphSort ( T * pData, int iCount, U COMP, V ACC ){
  3. 	if ( iCount<2 )return;
  4. 

  5. 	typedef T * P;
  6. 	// st0 and st1 are stacks with left and right bounds of array-part.
  7. 	// They allow us to avoid recursion in quicksort implementation.
  8. 	P st0[32], st1[32], a, b, i, j;
  9. 	typename V::MEDIAN_TYPE x;
  10. 	int k;
  11. 

  12. 	const int SMALL_THRESH = 32;
  13. 	int iDepthLimit = sphLog2 ( iCount );
  14. 	iDepthLimit = ( ( iDepthLimit<<2 ) + iDepthLimit ) >> 1; // x2.5
  15. 

  16. 	k = 1;
  17. 	st0[0] = pData;
  18. 	st1[0] = ACC.Add ( pData, iCount-1 );
  19. 	while ( k ){
  20. 		k--;
  21. 		i = a = st0[k];
  22. 		j = b = st1[k];
  23. 

  24. 		// if quicksort fails on this data; switch to heapsort
  25. 		if ( !k ){
  26. 			if ( !--iDepthLimit ){
  27. 				sphHeapSort ( a, ACC.Sub ( b, a )+1, COMP, ACC );
  28. 				return;
  29. 			}
  30. 		}
  31. 

  32. 		// for tiny arrays, switch to insertion sort
  33. 		int iLen = ACC.Sub ( b, a );
  34. 		if ( iLen<=SMALL_THRESH ){
  35. 			for ( i=ACC.Add ( a, 1 ); i<=b; i=ACC.Add ( i, 1 ) ){
  36. 				for ( j=i; j>a; ){
  37. 					P j1 = ACC.Add ( j, -1 );
  38. 					if ( COMP.IsLess ( ACC.Key(j1), ACC.Key(j) ) )
  39. 						break;
  40. 					ACC.Swap ( j, j1 );
  41. 					j = j1;
  42. 				}
  43. 			}
  44. 			continue;
  45. 		}
  46. 

  47. 		// ATTENTION! This copy can lead to memleaks if your CopyKey
  48. 		// copies something which is not freed by objects destructor.
  49. 		ACC.CopyKey ( &x, ACC.Add ( a, iLen/2 ) );
  50. 		while ( a<b ){
  51. 			while ( i<=j ){
  52. 				while ( COMP.IsLess ( ACC.Key(i), x ) )
  53. 					i = ACC.Add ( i, 1 );
  54. 				while ( COMP.IsLess ( x, ACC.Key(j) ) )
  55. 					j = ACC.Add ( j, -1 );
  56. 				if ( i<=j ){
  57. 					ACC.Swap ( i, j );
  58. 					i = ACC.Add ( i, 1 );
  59. 					j = ACC.Add ( j, -1 );
  60. 				}
  61. 			}
  62. 

  63. 			// Not so obvious optimization. We put smaller array-parts
  64. 			// to the top of stack. That reduces peak stack size.
  65. 			if ( ACC.Sub ( j, a )>=ACC.Sub ( b, i ) ){
  66. 				if ( a<j ) { st0[k] = a; st1[k] = j; k++; }
  67. 				a = i;
  68. 			} else{
  69. 				if ( i<b ) { st0[k] = i; st1[k] = b; k++; }
  70. 				b = j;
  71. 			}
  72. 		}
  73. 	}
  74. }

sphinx 的这个二分查找没有问题，但是和我们平常的二分查找还是有点不同的。
它的左右边界都是开放的，即(a,b).

  
  
  1. /// generic binary search
  2. template < typename T, typename U, typename PRED >
  3. T * sphBinarySearch ( T * pStart, T * pEnd, const PRED & tPred, U tRef ){
  4. 	if ( tPred(*pStart)==tRef )return pStart;
  5. 	if ( tPred(*pEnd)==tRef )return pEnd;
  6. 

  7. 	while ( pEnd-pStart>1 ){
  8. 		if ( tRef<tPred(*pStart) || tPred(*pEnd)<tRef )break;
  9. 		T * pMid = pStart + (pEnd-pStart)/2;
  10. 		if ( tRef==tPred(*pMid) )return pMid;
  11. 		if ( tRef<tPred(*pMid) )pEnd = pMid;
  12. 		else pStart = pMid;
  13. 	}
  14. 	return NULL;
  15. }

要想去重，首先需要排序，所以这里假设容器是已经排完序的了。
然后假设 iDst 的上一个就是目前比较的值。
如果和上一个相等，则iSrc后移。
如果和上一个不相等，则找到一个新的值，将iDst位置置为新值，个数加1即可。

  
  
  1. /// generic uniq
  2. template < typename T, typename T_COUNTER >
  3. T_COUNTER sphUniq ( T * pData, T_COUNTER iCount ){
  4. 	if ( !iCount )return 0;
  5. 

  6. 	T_COUNTER iSrc = 1, iDst = 1;
  7. 	while ( iSrc<iCount ){
  8. 		if ( pData[iDst-1]==pData[iSrc] )iSrc++;
  9. 		else pData[iDst++] = pData[iSrc++];
  10. 	}
  11. 	return iDst;
  12. }
  13.
ygmdream
关注
专栏目录
【后量子密码】SPHINCS+ 算法（一）：FORS与超树（附源码分析）
听雨草堂
06-05 2221
OTS（One-Time Signature）是一种只能使用一次的签名方案。在OTS中，签名密钥只能用于生成一次签名，一旦签名被验证，密钥就不能再用于生成其他签名。Lamport OTS就是一种典型的OTS方案。FTS（Few-Time Signature）是一种可以使用有限次数的签名方案。在FTS中，签名密钥可以用于生成多次签名，但是每次签名都会暴露一些密钥信息，降低密钥的安全性。因此，FTS方案适用于需要多次签名的场景，但需要权衡签名次数和密钥安全性。
【后量子密码】SPHINCS+ 算法（二）：签名与验签（附源码分析）
听雨草堂
06-05 2562
本节介绍SPHINCS+ 算法的密钥生成、签名与验签。nnn：安全参数；www：Winternitz参数，WOTS+签名分解的基底；hhh：超树的高度；ddd：超树中子树的层数；kkk：FORS 树的数量；ttt：FORS 树的叶子节点数。
sphinx算法分析
02-13
本文对sphinx代码中涉及到的一部分算法进行说明，以便在阅读代码的时候，能更容易理解相关的代码。本文所整理的是其中的部分算法。
sphinx源码分析总结
djph26741的博客
04-05 122
http://www.cnblogs.com/bonelee/p/6667955.html shinx索引部分源码分析——过程：连接到CSphSource对应的sql数据源，通过fetch row取其中一行，然后解析出field，分词，获得wordhit，最后再加入到CSphSource的Hits里http://www.cnblogs.com/bonelee/p/6668015.html...
MySQL · 引擎介绍 · Sphinx源码剖析(三)
weixin_33859231的博客
10-21 94
在本节中我会介绍Sphinx在构建索引之前做的一些事情，主要是从mysql拉取数据保存，然后分词排序保存到内存等等一系列的操作。下面是几个相关指令 sql_query = \ SELECT id, group_id, UNIX_TIMESTAMP(date_added) AS date_added, \ ...
sphinx4-5prealpha-src.zip
12-25
2. **源码阅读**：源代码可以帮助理解Sphinx4的工作原理，学习如何自定义模型、配置文件以及交互逻辑。 3. **训练与测试**：利用Sphinx4提供的工具对声学模型和语言模型进行训练，然后用测试集验证模型性能。 4. *...
Sphinx全文检索引擎for Linux v2.0.6
05-17
1. 下载Sphinx的源代码包，解压到本地目录。 2. 使用编译工具（如`autoconf`和`make`）编译并安装。 3. 配置Sphinx的配置文件`sphinx.conf`，指定数据源、索引设置、监听端口等。 4. 生成索引，可以使用`indexer`...
Android平台使用PocketSphinx做离线语音识别，小范围语音99%识别率.zip
07-03
语言模型是识别过程中的关键部分，它决定了PocketSphinx可以识别的词汇和句子结构。对于小范围的语音识别，可以定制一个特定领域的语言模型，例如只包含特定命令或关键词，以提高识别准确性。语言模型通常以LM3或...
Python的分布式进化算法
04-05
它试图使算法显式和数据结构透明。它与Pythessing和Scoop.deap等平行机制的完美和谐有效，包括以下特征：。Python社区关注PEP 438的接受，我们已经移动了Deap的Pypi源版本。您可以找到最新的发布：...
sphinx搜索引擎索引结构优化
Thinking -Walking@未名
01-12 1867
sphinx搜索引擎索引结构优化。2年前工作中的内容，已成过眼烟云，分享一下，欢迎交流。
sphinx 参考手册和源程序
04-24
Coreseek 全文检索服务器 2.0 (Sphinx 0.9.8)参考手册和源程序 手册內容： 文档版本：v0.9 目录 1. 简介 1.1. 什么是 Sphinx 1.2. Sphinx 的特性 1.3. 如何获得 Sphinx 1.4. 许可协议 1.5. 作者和贡献者 1.6. 开发历史 2. 安装 2.1. 支持的操作系统 2.2. 依赖的工具 2.3. 安装 Sphinx 2.4. 已知的问题和解决方法 2.5. Sphinx 快速入门教程 3. 建立索引 3.1. 数据源 3.2. 属性 3.3. 多值属性 ( MVA ： multi-valued attributes) 3.4. 索引 3.5. 数据源的限制 3.6. 字符集 , 大小写转换 , 和转换表 3.7. SQL 数据源 (MySQL, PostgreSQL) 3.8. xmlpipe 数据源 3.9. xmlpipe2 数据源 3.10. 实时索引 更新 3.11. 索引合并 4. 搜索 4.1. 匹配模式 4.2. 布尔查询 4.3. 扩展查询 4.4. 权值计算 4.5. 排序模式 4.6. 结果分组（聚类） 4.7. 分布式搜索 4.8. searchd 日志格式 5. API 参考 5.1. 通用 API 方法 5.1.1. GetLastError 5.1.2. GetLastWarning 5.1.3. SetServer 5.1.4. SetRetries 5.1.5. SetArrayResult 5.2. 通用搜索设置 5.2.1. SetLimits 5.2.2. SetMaxQueryTime 5.3. 全文搜索设置 5.3.1. SetMatchMode 5.3.2. SetRankingMode 5.3.3. SetSortMode 5.3.4. SetWeights 5.3.5. SetFieldWeights 5.3.6. SetIndexWeights 5.4. 结果集过滤设置 5.4.1. SetIDRange 5.4.2. SetFilter 5.4.3. SetFilterRange 5.4.4. SetFilterFloatRange 5.4.5. SetGeoAnchor 5.5. GROUP BY 设置 5.5.1. SetGroupBy 5.5.2. SetGroupDistinct 5.6. 搜索 5.6.1. Query 5.6.2. AddQuery 5.6.3. RunQueries 5.6.4. ResetFilters 5.6.5. ResetGroupBy 5.7. 额外的方法 5.7.1. BuildExcerpts 5.7.2. UpdateAttributes 6. MySQL 存储引擎 (SphinxSE) 6.1. SphinxSE 概览 6.2. 安装 SphinxSE 6.2.1. 在 MySQL 5.0.x 上 编译 SphinxSE 6.2.2. 在 MySQL 5.1.x 上编译 SphinxSE 6.2.3. SphinxSE 安装测试 6.3. 使用 SphinxSE 7. 报告 bugs 8. sphinx.conf 选项参考 8.1. Data source 配置选项 8.1.1. type 8.1.2. sql_host 8.1.3. sql_port 8.1.4. sql_user 8.1.5. sql_
sphinx
03-31
sphinx
高性能搜索引擎sphinx源码解析之搜索过程和评分公式
热门推荐
zhaojianting的博客
10-18 2万+
技术交流qq群： 659201069 **鄙人的新书《elasticsearch7完全开发指南》，欢迎订阅！** ----- https://wenku.baidu.com/view/8ff2ce94591b6bd97f192279168884868762b8e7 《kibana权威指南》 ---- https://wenku.baidu.com/view/24cfee1ce43a...
全文检索之sphinx源码分析--检索流程
pzlpy的博客
08-27 552
Sphinx查询时最关注的是match里面的几个关键字的查询方式，因此每个检索语句下发到每个索引文件中去的时候首先做的就是对关键字进行结构化构建，得到的第一棵树是n叉树，然后这颗n叉树会进行第二次重构，重构以后的就是一颗有序的二叉树，每个二叉树非叶子节点就是需要做的操作，而每个叶子结点都代表了一个关键字。     上图为sphParseExtendedQuery函数构建的一颗n叉树，代表了m
全文检索之sphinx源码分析--配置文件和轮转操作
pzlpy的博客
08-31 371
从索引的数据来源、实时可见性的角度来看，我们可以认为conf配置文件是Sphinx组件的中心。所有有关数据来源、索引文件包含的数据量、数据属性、检索程序searchd监听的端口、响应时间等等一系列配置参数都来自conf文件。     下面以一些典型的配置文件配置项来进行解释：     source xxx：基本数据来源，每次创建索引文件时都是都执行该段的sql_qurey语句，从中获取基本
mysql sphfiks_MySQL · 引擎介绍 · Sphinx源码剖析(三)-阿里云开发者社区
weixin_32968239的博客
01-19 124
在本节中我会介绍Sphinx在构建索引之前做的一些事情，主要是从mysql拉取数据保存，然后分词排序保存到内存等等一系列的操作。下面是几个相关指令sql_query = \SELECT id, group_id, UNIX_TIMESTAMP(date_added) AS date_added, \title, content \FROM documentssql_query_range = SE...
sphinx中用的束搜索（Beam Search Algorithm）算法2
hezhourongro的专栏
11-11 1441
接着上次继续说明束搜索算法，下面是算法示例和算法效率分析 1  算法示例 例1  B=1  （B为束宽度） 下面用表格表示算法流程，用两列表示每一个主循环，第一列每一个加编号的循环显示加入到set的节点，它们按启发权值排序，权值相同的按字母排序，一个节点只被加入到SET一次。第二列每一个编号的循环列出了在第二部分的主循环中SET中的节点，它们将被加入到BEAM中。两列都显示了hash tab
【零基础入门哈希签名架构，从Lamport到SPHINCS+】第一集 哈希签名始祖 Lamport 方案及其改进版本（Merkle，Winternitz）
最新发布
m0_50572808的博客
10-14 1329
【零基础入门哈希签名架构，从Lamport到SPHINCS+】 第一集 哈希签名始祖Lamport方案及其改进版本
sphinx4整体架构分析
weixin_34050389的博客
07-12 193
sphinx4最大的优点就是跨平台和灵活，它应用到了很多优秀的设计思想，如注解，设计模式等。下面总结一下它的特点：1、高度可配置的前端点处理2、支持孤立词，n-gram，context free语法3、支持任意unit context sizes来提高识别率4、允许使用新的搜索和裁剪算法sphinx4的架构图：从大的范围来说，可以分为3个部分：前端点，×××和基础知识。大致的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值