abp竞赛－之－文本文件词频查询 优化报告

                         abp竞赛－之－文本文件词频查询 优化报告
                           HouSisong@GMail.   2007.03.15com

tag：　abp,单词统计,比赛,hash,速度优化,优化报告
摘要： 以前参加过几次abp论坛的比赛 http://www.allaboutprogram.com/bb (现在的www.cpper.com/c) 
  其中的一个竞赛的题目是《文本文件词频查询》，本文章把自己的参赛代码的优化的思路整理出来；
  很多时候优化后的版本最高达到了STL实现版本的20倍!   

(2007.04.09 确认从MFC移植过来的时候引入了一个bug,“FILE* file=fopen(argv[1], "r" ); ”应该为“FILE* file=fopen(argv[1], "rb" );  ” 找了我好久:(   谢谢 hf1414 ！)

  (2007.03.17修正一个在vc2005编译器下访问vector的bug，将代码 “TNode** end=&(_vbase[_hash_power]); ” 改为 “base_t::iterator end=_vbase.end();” )
  
  (abp现在还能够访问(只读)，会员很多都“搬迁”到了 www.cpper.com/c  :)

文本文件词频查询 竞赛要求:

OS：Windows 2000/XP 
Compiler：VC6/VC.net/VC.net 2003 
评判标准：正确性+速度 
截止时间：2003年10月11日前（含） 
方法：每个人可以多次提交。每次提交完了，我会告诉你你的成绩和最快的人的成绩。 
内容： 
一个文件，仅由大小写字母，空格和换行符组成。我们称一个词为连续的大小写字符，两边是空格或者文件头/尾。词大小写敏感。 
某个词的词频是这个词在这个文件里面出现的次数。 
要求，输入一个文件（至少有一个词，并且最大词频的词只有一个），输出那个词频最大的词。 
譬如，输入： 
aaa bbb 
ccc ddd 
aaa 

输出： 
aaa 

补充一句：文件可能非常大。（xxxM，xG） 
还有就是，文件中不会出现TAB。

 (测试程序的时候，我们将vc目录中的源代码文件合成了一个数据文件来作为测试数据)

一个“标准”C++实现版本： (可以作为一个STL使用的实例:)

#pragma warning ( disable : 4786 )
#include <iostream> 
#include <fstream> 
#include <string> 
#include <map> 
#include <time.h>
using namespace std; 

int main(int argc, char* argv[]) 
{ 
   //assert(argc==2);
   clock_t start=clock();
   const char* file_name=argv[1];
   ifstream in_file(file_name); 

   map<string,int> word_table; 
   string max_word;  
   long max_count=0;
   string word; 
   while(in_file >> word) 
   { 
      long old_count_inc=(++word_table[word]);
      if(old_count_inc>max_count)
      {
          max_word=word;
          max_count=old_count_inc;  
      }
   } 
   cout<<" Word: "<<max_word<<" Count: "<<max_count<<endl; 
   cout<<" Seconds = "<<( (double)(clock()-start)/CLOCKS_PER_SEC )<<endl;

   return 0; 
} 

 
我用的测试编译器vc6.0 , CPU赛扬2.0G
下面的代码很多时候速度是上面的版本的20倍,源代码如下(优化说明在代码之后);
（我以前提交的代码使用了MFC库，为了容易编译和理解，我做了一些代码调整,去除MFC依赖，把一个复杂的代码循环展开删除了，可能慢了10%） 

#pragma warning ( disable : 4786 )
#include <stdio.h>
#include <time.h>
#include <iostream>  
#include <string> 
#include <vector> 
#include <algorithm> 

namespace { 
   class CMyAllot  
   { 
      enum { chunk_size=1024*256  };//块大小 
      char*   _cur; 
      char*   _end; 
      std::vector<char*> _vector; 
      void*    _new_else(unsigned int size); 
   public: 
      CMyAllot() :_end(0),_cur(0) { } 
      virtual ~CMyAllot() { if (!_vector.empty()) DelAll(); } 
      inline void* _fastcall   New(unsigned int size) 
      { 
         size=((size+3)>>2<<2);//4字节边界对齐 
         if ((int)size<(_end-_cur))//够用 
         { 
            char* result=_cur; 
            _cur+=size; 
            return result; 
         } 
         else //不够用 
            return _new_else(size); 
      } 
      void   DelAll() 
      { 
         for (int i=0;i<(int)_vector.size();++i) 
            delete [] (_vector[i]); 
         _vector.clear(); 
      } 
   }; 
   void* CMyAllot::_new_else(unsigned int size) 
   { 
      if (size>(chunk_size>>2))//不够用，而且需要的空间较大 
      { 
         char* result=new char[size]; 
         char* old_back=_vector.back(); 
         _vector[_vector.size()-1]=result; 
         _vector.push_back(old_back); 
         return result; 
      } 
      else //不够用，开辟新的空间 
      { 
         char* result=new char[chunk_size]; 
         _cur=result+size; 
         _end=result+chunk_size; 
         _vector.push_back(result); 
         return result; 
      } 
   } 


   struct TNode//hash表使用的节点类型(链表) 
   { 
      TNode*         pNext; 
      unsigned int   count; 
      char         str[1];   //不一定只有一个字节,会根据字符串分配空间 
      struct TComp//返回时的排序准则 
      { 
         bool operator()(const TNode* l,const TNode* r) 
         { 
            if ((l->count)==(r->count)) 
            { 
               return std::string(&l->str[0])<(&r->str[0]); 
            } 
            else 
               return (l->count)>(r->count); 
                
         } 
      }; 
   }; 
   inline unsigned int _fastcall hash_value(char* begin,char* end) 
   { 
      unsigned int result=0;       
      do{  
         result=5*result+(*begin);   //利用asm: lea reg0,[reg1*4+reg1],并且5是质数 
      }while((++begin)!=end); 
      return result; 
   } 
   inline unsigned int _fastcall hash_value(char* pstr) 
   { 
      unsigned int result=0; 
      do{  result=5*result+(*pstr); ;   //利用asm: lea reg0,[reg1*4+reg1],并且5是质数 
      }while((*(++pstr))); 
      return result; 
   } 
   //测试字符串是否相同, 如果需要不区分大小写，修改这个函数和hash函数就可以了 
   inline  bool _fastcall test_str_EQ(char* begin,char* end,char* str) 
   { 
      //for (;begin!=end;++begin,++str) 
      //   if ( (*begin)!=*(str) ) return false; 
      do{ 
         if ( (*begin)!=*(str) ) return false; 
         ++begin;++str; 
      }while(begin!=end); 
      return true; 
   } 
} 


class CHashSet 
{ 
   typedef std::vector<TNode*> base_t; 

   inline unsigned int  hash_index(char* begin,char* end) const 
      { return hash_value(begin,end)&(_hash_mask); } 
   inline unsigned int  hash_index(char* pstr) const 
      { return hash_value(pstr)&(_hash_mask); } 

   void         resize(); 
   void _fastcall   move_insert(base_t& v,TNode* pOldNode) const; 
   TNode*   _fastcall NewNode(char* begin,char* end); 
   void         Sort(base_t& v,unsigned int sortCount); 

   unsigned int      _hash_power; 
   unsigned int      _hash_mask; 
   unsigned int      _node_count; 
   base_t            _vbase; 
   CMyAllot         _allot; 

   void _fastcall   else_insert(TNode* pNode,char* begin,char* end); 

public: 
   CHashSet(); 
   virtual ~CHashSet(); 
   unsigned int      size() const { return _node_count; } 
   unsigned int      sum(); 
   void _fastcall      insert(char* begin,char* end); 
   void            GetStrList(std::ostream& cout,unsigned int sortCount);    

}; 



CHashSet::CHashSet() 
:_hash_power(2),_vbase((unsigned int)(_hash_power),(TNode*)0)//注意次序 
{ 
   _node_count=0; 
   _hash_mask=_hash_power-1;//_hash_power=1<<n; 
} 

CHashSet::~CHashSet() 
{ 
   _allot.DelAll(); 
} 

unsigned int CHashSet::sum() 
{ 
   unsigned int sum=0; 
   if(_node_count>0) 
   { 
      base_t::iterator end=_vbase.end();
      for (base_t::iterator i=_vbase.begin();i<end;++i) 
      { 
         TNode* pNode=(*i); 
         while (pNode!=0) 
         { 
            sum+=pNode->count; 
            pNode=pNode->pNext; 
         } 
      } 
   } 
   return sum; 
} 

void _fastcall CHashSet::insert(char* begin,char* end) 
{ 
   unsigned int index=hash_index(begin,end); 
   TNode* pNode=_vbase[index]; 
   if (!pNode)//节点还没有使用 
   { 
      _vbase[index]=NewNode(begin,end); 
      ++_node_count; 
   } 
   else 
   { 
      if (test_str_EQ(begin,end,pNode->str))//累加 
         ++(pNode->count); 
      else 
         else_insert(pNode,begin,end); 
   } 
} 

void _fastcall CHashSet::else_insert(TNode* pNode,char* begin,char* end) 
{ 
   while (true) 
   { 
      if(!(pNode->pNext)) 
      { 
         pNode->pNext=NewNode(begin,end); 
         ++_node_count; 
         if(_node_count>=(_hash_power)) 
            resize(); 
         break; 
      } 
      else if (test_str_EQ(begin,end,pNode->pNext->str)) 
      { 
         ++(pNode->pNext->count); 
         break; 
      } 
      pNode=pNode->pNext; 
   }; 
} 


void _fastcall CHashSet::move_insert(base_t& v,TNode* pOldNode) const 
{ 
   TNode*& pNode = v[hash_index(pOldNode->str)]; 
   pOldNode->pNext=0; 
   if (!pNode)//节点还没有使用 
   { 
      pNode=pOldNode; 
   } 
   else 
   { 
      if (!pNode->pNext) 
      { 
         pNode->pNext=pOldNode; 
      } 
      else 
      { 
         TNode* pListNode=pNode->pNext; 
         while (pListNode->pNext!=0) 
            { pListNode=pListNode->pNext; } 
         pListNode->pNext=pOldNode; 
      } 
   } 
} 


TNode* _fastcall CHashSet::NewNode(char* begin,char* end) 
{ 
   TNode* pNode=(TNode*)(_allot.New(sizeof(TNode)+end-begin)); 
   pNode->pNext=0; 
   pNode->count=1; 
   char* i=pNode->str; 
   //for (;begin!=end;++i,++begin) 
   //   (*i)=(*begin); 
   do{  
      (*i)=(*begin); ++i,++begin; 
   } while(begin!=end); 
   (*i)=char(0); 

   return pNode; 
} 

void CHashSet::resize() 
{ 
   if(_node_count>=(_hash_power)) 
   { 
      base_t::iterator end=_vbase.end();
      _hash_power<<=2; 
      _hash_mask=(_hash_power)-1; 
       
      base_t   new_vbase(_hash_power,(TNode*)0); 
      for (base_t::iterator i=_vbase.begin();i!=end;++i) 
      { 
         TNode* pNode=(*i); 
         while (pNode!=0) 
         { 
            TNode* temp=pNode->pNext; 
            move_insert(new_vbase,pNode); 
            pNode=temp; 
         } 
      } 
      _vbase.swap(new_vbase); 
   } 
} 



//// 


void   CHashSet::Sort(base_t& v,unsigned int sortCount) 
{ 
   if (sortCount==1) 
   { 
      v.resize(1); 
      base_t::iterator end=_vbase.end(); 
      TNode* maxNode=_vbase[0]; 
      TNode::TComp op; 
      for (base_t::iterator i=_vbase.begin();i!=end;++i) 
      { 
         TNode* pNode=(*i); 
         while (pNode!=0) 
         { 
            if ( (maxNode==0)||(op(pNode,maxNode)) ) 
               maxNode=pNode; 
            pNode=pNode->pNext; 
         } 
      } 
      v[0]=maxNode; 
   } 
   else 
   { 
      v.resize(_node_count); 
      int index=0; 
      if(_node_count>0) 
      { 
         TNode** end=&(_vbase[_hash_power]); 
         for (TNode** i=&(_vbase[0]);i!=end;++i) 
         { 
             
            TNode* pNode=(*i); 
            while (pNode!=0) 
            { 
               v[index]=pNode; 
               ++index; 
               pNode=pNode->pNext; 
            } 
         } 
      } 
      std::partial_sort(v.begin(),v.begin()+sortCount,v.end(),TNode::TComp()); 
   } 
} 

void CHashSet::GetStrList(std::ostream& cout,unsigned int sortCount) 
{ 
   if (_node_count>=1) 
   { 
      if (sortCount==0) 
         sortCount=_node_count; 
      else if (_node_count<sortCount)
         sortCount=_node_count; 
      base_t v; 
      Sort(v,sortCount); 
      for (int i=0;i<(int)sortCount;++i) 
      { 
          std::cout<<" 单词: "<<(&(v[i]->str[0]))<<" 计数: "<<(v[i]->count)<<std::endl; 
      } 
   } 
} 



class CWords  
{ 
private: 
   enum { cibuf_size = 4096 };      //缓冲区最佳大小 
   int            buf_size;         //动态缓冲区大小 
   char*         pBuf;            //指向缓冲区 
   static void CreateGainTab();      //构造“词”分析用的表 
   int  privateGainWord(int dx,int start_offset,bool isEndGain); 

   inline int  GainWord(int dx,int start_offset);//从缓冲区获取词； 
   inline void endGainWord(int dx,int start_offset);//从缓冲区获取词,处理文件尾； 
   void _fastcall PushWord(char* begin,char* end); 
   __int64      _CPUCount; 
   CHashSet   _hash_set; 
public: 
   CWords(); 
   virtual ~CWords(); 

   void toDo(FILE* file);//循环读取文件数据到内存缓冲区 
   void GetResult(std::ostream& cout,unsigned int sortCount); 
}; 

namespace { 
   static unsigned int   GainTab[256];   //进行词法分析的表 
} 
//构造“词”分析用的表 
void CWords::CreateGainTab() 
{ 
   // 
   static bool IsDo=false; 

   if (IsDo) return; 

   for (int i=0;i<256;++i) 
   { 
      if (   ((i>='A')&&(i<='Z')) 
         || ((i>='a')&&(i<='z')) 
         //|| (i=='_') 
         //|| ((i>='0')&&(i<='9')) 
         ) 
         GainTab[i]=unsigned int(-1); 
      else 
         GainTab[i]=0; 
   } 

   IsDo=true; 
} 


CWords::CWords() 
{ 
} 

CWords::~CWords() 
{ 
} 

#define asm __asm
__declspec( naked ) __int64 CPUCycleCounter()//获取当前CPU周期计数(CPU周期数) 
{ 
   asm 
   { 
      RDTSC    //0F 31  //eax,edx 
      ret 
   } 
} 



//循环读取文件数据到内存缓冲区 
void CWords::toDo(FILE* file) 
{ 
   _CPUCount=::CPUCycleCounter(); 

   std::vector<char> BufData(cibuf_size); 
   buf_size=BufData.size(); 
   pBuf=&BufData[0]; 

   //get file length
   fseek(file,0,SEEK_END);   
   int file_length = ftell(file);   
   fseek(file,0,SEEK_SET);      
   int file_pos =0;   
    
   CreateGainTab(); 
   int dx=0; 
   int start_offset=0; 
   while (true) 
   { 
      if (file_pos+(buf_size-dx)<=file_length) 
      { 
         fread(pBuf+dx,buf_size-dx,1,file); 
         file_pos+=(buf_size-dx);
         dx=GainWord(dx,start_offset); 

         start_offset=0;
         if (dx<0) //处理超长单词 
         { 
            start_offset=buf_size+dx;//放大缓冲区 
            dx=buf_size; 
            BufData.resize(dx*2); 
            buf_size=BufData.size(); 
            pBuf=&BufData[0]; 
         } 
         else //if ( (dx<(cibuf_size>>1)) && (buf_size>(cibuf_size<<1)) ) 
         { 
            //BufData.resize(cibuf_size);//减小缓冲区 
            //pBuf=&BufData[0]; 
            //buf_size=BufData.size(); 
         } 

      } 
      else 
      { 
         int bordercount=(int)(file_length-file_pos); 
         if (bordercount>0) 
         { 
             fread(pBuf+dx,bordercount,1,file); 
             buf_size=dx+bordercount; 
             //file_pos+=(bordercount);
             endGainWord(dx,start_offset); 
         } 

         break; //end while
      } 
   } 
   _CPUCount=::CPUCycleCounter()-_CPUCount; 
} 

int CWords::privateGainWord(int dx,int start_offset,bool isEndGain)
{
   char* pStart=pBuf+start_offset; 
   char* pEnd=pBuf+buf_size; 
   int IsInWord=(dx!=0)?int(-1):0;   //是否处于“词”中 
   char* i=pBuf+dx; 

   for (;i!=pEnd;++i) 
   { 
      if (IsInWord^GainTab[*(unsigned char*)i]) 
      { 
         if (IsInWord) 
            PushWord(pStart,i); 
         else 
            pStart=i; 
         IsInWord=(~IsInWord); 
      } 
   } 

   ///////// 
   dx=0; 
   if (IsInWord) 
   { 
      if (isEndGain)
          PushWord(pStart,pEnd);  //最末尾的一个词 
      else
      {
          dx=pEnd-pStart; 
          if (dx>(buf_size>>1))//超长单词特殊处理 
             dx=(-dx); //特殊标记！
          else 
          { 
             for (int i=0;i<dx;++i)//把没有处理完的单词拷贝到缓冲区开头 
                pBuf[i]=pStart[i]; 
          } 
      }
   } 
   return dx; 
}


int CWords::GainWord(int dx,int start_offset) 
{ 
    return privateGainWord(dx,start_offset,false);
} 


void CWords::endGainWord(int dx,int start_offset) 
{ 
    privateGainWord(dx,start_offset,true);
} 


void CWords::GetResult(std::ostream& cout, unsigned int sortCount) 
{ 
   std::cout<<" 无重复单词数: "<<_hash_set.size()<<" 单词总数: "<<_hash_set.sum()<<std::endl; 
   std::cout<<" CPU周期计数: "<<(long)_CPUCount<<std::endl; 
   _hash_set.GetStrList(cout,sortCount); 
} 


inline void _fastcall CWords::PushWord(char* begin,char* end) 
{ 
   _hash_set.insert(begin,end); 
} 


/////////////////////////////// 



int CreateTxtFile(char* argv[]); 
int toWork(int argc,char* argv[]); 
const char sParameter []="Cpt_hss filename [/N] "; 

//主程序 
int main(int argc, char* argv[]) 
{ 
   if (argc<=1) 
   { 
      std::cout<<("请输入文件名称! "); 
      std::cout<<sParameter;    
      std::cout<<std::endl;   
      return 0; 
   } 
   if (std::string(argv[1])=="/?") 
   { 
      std::cout<<("统计文件中单词出现频率。 ");    
      std::cout<<(sParameter);       
      std::cout<<("  filename      指定需要进行统计的文件的名称 ");       
      std::cout<<("  [/N]          显示出现频率最高的前N个单词; ");       
      std::cout<<("                如果单词出现频率相同,则按字母顺序排列; ");       
      std::cout<<("                N默认为1; ");       
      std::cout<<("                当N=0时,表示全部显示。 ");       
      std::cout<<std::endl;
      return 0; 
   } 

   return toWork(argc,argv); 

} 

int toWork(int argc,char* argv[]) 
{ 
   clock_t start=clock();

   FILE* file=fopen(argv[1],"rb"); 
   if (file==0) 
   { 
      std::cout<<("打开文件时发生错误! "); 
      std::cout<<(sParameter);       
      return 0; 
   } 
   unsigned int sortCount=1; 
   if (argc==3) 
      sortCount=atoi(argv[2]+1); 

   CWords words; 
   words.toDo(file);    

   fclose(file); 
   words.GetResult(std::cout,sortCount); 
   std::cout<<" Seconds = "<<( (double)(clock()-start)/CLOCKS_PER_SEC )<<std::endl;
   return 0; 
}

 

重点优化说明: （这是本篇文章的重点，讲解一些基本的优化策略）

1.在读取文件方面，使用了一个自己管理的内存缓冲区来读取文件的数据；
（这样处理以后读文件占的时间约占总时间的1/7，还可以进一步优化：
进一步改进方案a：可以考虑用另一个线程异步来加载文件数据(当前处理大量文件数据的高效方案)；
进一步改进方案b：如果文件不太大可以考虑使用内存映射技术来优化这一块，代码也简单很
多，而单词的表示也可以采用一个指针加一个长度(或者用头尾两个指针，或者一个指针+哨兵
位(推荐))来表示，从而避免一次深拷贝）

2.建立了一个查询表GainTab[256]用来判断一个字母是否是单词还是空白区域；
比如：可以把( ((C>='A')&&(C<='Z'))||((C>='a')&&(C<='z')) ) 简写为 ( GainTab[C]!=0 )

(其实也可以建立一个64k的表来捕捉状态，同时用两个字节来查表...)
  
3.把查找单词的扫描过程理解为从单词区域到空白区域的状态转换(这句可能不好理解);
比如一般常见的实现伪代码：

char* i=pBegin;
while (i!=pEnd)
{
    while((i!=pEnd)&&(!GainTab[*(unsigned char*)i])) //寻找到单词开头
        ++i;
    pStart=i;
    while((i!=pEnd)&&(GainTab[*(unsigned char*)i]))  //寻找该单词结束位置
        ++i;
    if (pStart!=i)
        PushWord(pStart,i);
}

 我的代码：

for (char* i=pBegin;i!=pEnd;++i) 
{ 
    if (IsInWord^GainTab[*(unsigned char*)i]) //捕捉所属区域状态的变化
    { 
        if (IsInWord) 
            PushWord(pStart,i); 
        else 
            pStart=i; 
        IsInWord=(~IsInWord); 
    } 
} 

该算法处理两个状态:是否在单词中、“是否在单词中”的状态是否改变；
从而消除了内部的一个循环框架，这在单词和空际较小时将带来更多好处;
（在本程序中可能所起作用不大，这里耗的时间不多，反而调用PushWord的花掉的时间更多）

(还有一个有用的见解：“经过3个字节最多能够计数一个单词”，比如利用这个观点可以建立
2字节或3字节的查询表(表的大小的取舍需要考虑CPU的缓冲区大小)，同时处理更多的字节)

4.为了优化单词使用的内存，减少动态内存分配，自定义了一个CMyAllot类来管理内存的分配

5.我使用了一个自定义的hash表CHashSet(准确点应该叫做map)来储存找到的单词(hash表具有平
均常数时间的单词查找能力)，表的大小会随着无重复单词数的增加而动态增长：某个HashItem
不可用时，会把新的单词加到HashItem后面，即HashItem形成一个单向list,当hash表的负债超过
某个阈值的时候,就会增大表的大小,然后所有的元素重新转移到新的表；

6.我的hash表的大小只可能为2的整数次方，所以hash值在映射到HashItem的序号时可以使用快速
的&运算(hash_value&_hash_mask);  等价于(hash_value%hash_size) , 优化掉一次求余运算
(求余和除法都是很慢的操作)
 

补充: 我尝试过把char字符流当作wchar_t* 流来处理，希望提高吞吐量
但为保证结果正确代码逻辑变得稍微复杂了一些，结果在我的机子上速度几乎没有变！