对tinyxpath的一些简单优化

tinyxml很好用，简单，通常情况下足够用，很好。

不过xpath也是很好的东西，tinyxml里面没有直接的支持，网上找了找，有一个tinyxpath，拿下来看看

跑了一个简单的程序，分析一个gccxml生成的xml，文件大概有1m，很莫名其妙的，一个简单的xpath查询，感觉好慢好慢

 

#include  " stdafx.h "
#include  " direct.h "
#include  < windows.h >
#include  < iostream >
#include  < string >

#include  " xpath_processor.h "
#include  " xpath_static.h "

using   namespace  std;

int  _tmain( int  argc, _TCHAR *  argv[])
... {
    TiXmlDocument oDoc;
    DWORD starttime = GetTickCount();
    oDoc.LoadFile("TestGcc.xml");
    DWORD endtime = GetTickCount();
    cout<<"time use:"<<endtime - starttime<<endl;

    if(oDoc.Error())
    ...{
        cout<<oDoc.ErrorDesc()<<endl;
        return -1;
    }
    string str;
    cin>>str;
    cout<<str<<endl;
    starttime = GetTickCount();
    TiXmlNode* node = TinyXPath::XNp_xpath_node(oDoc.RootElement(), "//File[@name="TestGccXml.h"]");
    endtime = GetTickCount();
    cout<<"time use:"<<endtime - starttime<<endl;
    cin>>str;
    if(node == NULL)
        return -1;
    TiXmlElement* e = node->ToElement();
    if(e == NULL)
        return -1;
    cout<<e->Value()<<endl;
    return 0;
}

就是上面的程序，vc9 release 运行结果：

time   use : 94
hh
hh
time   use : 2776
jj
File
请按任意键继续 .   .   .

tinyxml分析，大概50~100ms，可以忍受，毕竟这个要求不高

可是xpath的查询，就能到上面的30倍以上，完全忍受不了！

用profile分析，瓶颈存在于node_set::o_exist_in_set上，一共执行了56967次，oh my god！

看了看tinyxpath的代码，结果发现node_set类里面的处理，完全的没有效率

    /**/ /// List of node pointers to the 
     const   void   **  vpp_node_set;
    /**/ /// Attributes flag list
    bool   *  op_attrib;

判断是否已有

bool  node_set::o_exist_in_set (
    const  TiXmlBase  *  XBp_member)     /**/ ///< Check if a base exist in the node set
{
   unsigned u_node;

    for  (u_node  =   0 ; u_node  <  u_nb_node; u_node ++ )
       if  (vpp_node_set [u_node]  ==  XBp_member)
          return   true ;
    return   false ;
}

插入操作

   vpp_new_list  =   new   const   void   *  [u_nb_node  +   1 ];
   op_new_list  =   new   bool  [u_nb_node  +   1 ];
    if  (u_nb_node)
    ... {
      memcpy (vpp_new_list, vpp_node_set, u_nb_node * sizeof (void *));
      delete [] vpp_node_set;
      memcpy (op_new_list, op_attrib, u_nb_node * sizeof (bool));
      delete [] op_attrib;
   }
   vpp_new_list [u_nb_node]  =  ( const   void   * ) XBp_member;
   vpp_node_set  =  vpp_new_list;
   op_new_list [u_nb_node]  =  o_attrib;
   op_attrib  =  op_new_list;
   u_nb_node ++ ;

如上，判断set中是否存在，使用线性查找，添加操作，new出来新数组，然后copy，append

简单，不过，实在慢

自己改了改

加了一个bool值，因为node_set最后要按照xml document顺序排序

   unsigned u_nb_node;
    /**/ /// List of node pointers to the 
     const   void   **  vpp_node_set;
    /**/ /// Attributes flag list
    bool   *  op_attrib;
    bool  op_sortbydoc;

构造函数初始化

   node_set () 
    ... {
      u_nb_node = 0; 
      vpp_node_set = NULL;
      op_attrib = NULL;
      op_sortbydoc = false;
   }

判断是否存在的时候，用的是二分查找

/**/ /// Internal utility function for node set sorting
static   int  i_compare_ptr (
                            const   void   *  vp_1,    /**/ ///< Ptr to first element to compare
                           const void * vp_2)   ///< Ptr to second element to compare
{
     return  ( * (ptrdiff_t * )vp_1)  -  ( * (ptrdiff_t * )vp_2);
}

static   int  binary_search_first_not_less_then(  void *  key,  void *  arr,  int  size,  int  ( * func)( const   void * ,  const   void * ) )
... {
    void** k = (void**)key;
    void** r = (void**)arr;
    int low=0, high=size-1, mid;
    while( low < high )
    ...{
        mid = (low + high) / 2;
        int cmp_result = func(k, r+mid);
        if( cmp_result > 0 )
            low = mid + 1;
        else if( cmp_result == 0 )
            return mid;
        else
            high = mid;
    }
    if( low > high )
        return -1;
    else if(func(k, r+high) > 0)
        return -1;
    else
        return high;
}

/**/ /// Checks if a node exist in the node set
bool  node_set::o_exist_in_set (
    const  TiXmlBase  *  XBp_member)     /**/ ///< Check if a base exist in the node set
{
    int  i_index  =  binary_search_first_not_less_then( & XBp_member, vpp_node_set, u_nb_node, i_compare_ptr);
    return  i_index  >=   0   &&  vpp_node_set[i_index]  ==  XBp_member;
}

添加的时候，直接排好序，本来要调用o_exist_in_set的，不过为了后面插入方便，直接用binary_search_first_not_less_then函数，找第一个不小于的元素

/**/ /// Adds a new node in the node set
void  node_set::v_add_base_in_set (
    const  TiXmlBase  *  XBp_member,     /**/ ///< Base to add (node or attribute)
   bool o_attrib)                   ///< true if the base is an attribute, false if it's a node
{
    const   void   **  vpp_new_list;
    bool   *  op_new_list;

    if  (op_sortbydoc)
    ... {
      op_sortbydoc = false;
      for(unsigned i=1; i<u_nb_node; ++i)
      ...{
         int i_insert = binary_search_first_not_less_then(vpp_node_set+i, vpp_node_set, i, i_compare_ptr);
         if(i_insert >=0)
         ...{
             const void* vp_tmp = vpp_node_set[i];
             bool op_tmp = op_attrib[i];
             memmove(vpp_node_set+i_insert+1, vpp_node_set+i_insert, (i-i_insert)*sizeof(void*));
             memmove(op_attrib+i_insert+1, op_attrib+i_insert, (i-i_insert)*sizeof(bool));
             vpp_node_set[i_insert] = vp_tmp;
             op_attrib[i_insert] = op_tmp;
         }
         
      }
      qsort (vpp_node_set, u_nb_node, sizeof (vpp_node_set[0]), i_compare_ptr);
   }
    int  i_index  =  binary_search_first_not_less_then( & XBp_member, vpp_node_set, u_nb_node, i_compare_ptr);
    if (i_index  >=   0   &&  vpp_node_set[i_index]  ==  XBp_member)
        return ;
    // if (o_exist_in_set (XBp_member))
    //    return;
      
   vpp_new_list  =   new   const   void   *  [u_nb_node  +   1 ];
   op_new_list  =   new   bool  [u_nb_node  +   1 ];
    if  (u_nb_node)
    ... {
      if(i_index >= 0)
      ...{
          memcpy (vpp_new_list, vpp_node_set, i_index * sizeof (void *));
          memcpy (vpp_new_list+i_index+1,
                    vpp_node_set + i_index,
                    (u_nb_node-i_index) * sizeof (void *));
          delete [] vpp_node_set;
          memcpy (op_new_list, op_attrib, i_index * sizeof (bool));
          memcpy (op_new_list+i_index+1,
                    op_attrib + i_index,
                    (u_nb_node-i_index) * sizeof (bool));
          delete [] op_attrib;
      }
      else
      ...{
          memcpy (vpp_new_list, vpp_node_set, u_nb_node * sizeof (void *));
          delete [] vpp_node_set;
          memcpy (op_new_list, op_attrib, u_nb_node * sizeof (bool));
          delete [] op_attrib;
          i_index = u_nb_node;
      }
   }
    else
       i_index  =  u_nb_node;
   vpp_new_list [i_index]  =  ( const   void   * ) XBp_member;
   vpp_node_set  =  vpp_new_list;
   op_new_list [i_index]  =  o_attrib;
   op_attrib  =  op_new_list;
   u_nb_node ++ ;

}

最后，在v_document_sort里面给o_sortbydoc设为true

 

void  node_set::v_document_sort ( const  TiXmlNode  *  XNp_root)
... {
   ptr_2_and_flag * p2afp_list;
   unsigned u_node;

   if (u_nb_node < 2)
      return;

   p2afp_list = new ptr_2_and_flag [u_nb_node];
   op_sortbydoc = true;
   for (u_node = 0; u_node < u_nb_node; u_node++)
   ...{
      p2afp_list [u_node] . vp_node = vpp_node_set [u_node];
      p2afp_list [u_node] . o_flag = op_attrib [u_node];
      p2afp_list [u_node] . XNp_root = XNp_root;
   }
   qsort (p2afp_list, u_nb_node, sizeof (ptr_2_and_flag), i_compare_ptr_2_and_flag);
   for (u_node = 0; u_node < u_nb_node; u_node++)
   ...{
      vpp_node_set [u_node] = p2afp_list [u_node] . vp_node;
      op_attrib [u_node] = p2afp_list [u_node] . o_flag;
   }
   delete [] p2afp_list;
}

简单来说，就是按照预先排序，二分查找来优化。

运行结果

time use: 94
hh
hh
time use: 1216
hh
File
请按任意键继续. . .

嗯，时间少了一半多，很好。

继续的优化，可以考虑

数组分配操作，可以用类似vector的方式，一次分配一定内存，不要一次增加一个元素

用rb树代替数组

等等

再继续下去，可能就要考虑xpath解析的方式了，很明显，tinyxpath是先分析"//"，生成一个node_set，然后再加入其他条件，逐步筛选出结果来。否则，没法解释为什么会调用那么多次v_add_base_in_set。

不过，实际上可以一次筛选，只把符合的结果放入node_set中，这样就应该会快很多。

但，这样子实在是太麻烦，可能tinyxpath内部算法都要大幅改动了，hehe

 

另外，tinyxpath和tinyxml都是一路货，考虑的是在没有或者只有很少stl的环境下面也能用，所以，最多，只用了std::string，其他的数据结构都没有用标准库，实际上，node_set直接用std::set实现，应该就能的到最高效率，也不用那么麻烦了。

所以，还是用stl吧，嘿嘿

说句题外话，据说很少有人能直接一次写好二分查找算法，果然没错，这回二分查找还好说，不过二分查找第一个不小于的元素，还是搞出好几个小bug来。。。唉，为什么不用lower_bound呢

 

最后，还是说一句吧，这个xpath查询可以优化的，其实<File>节点只在第一级而已，所以"//File..."可以用"File..."代替，查询速度嘛，基本上都在1ms以内，hehe