博客园_明论

单体模式实现代码

2011-07-28T14:21:00Z

刚刚跟朋友讨论单体模式的实现，以下是我为公司写的基类的实现，应该是经过很多项目的考验的，拿出来跟大家探讨下，

/**
* @author konyel lin
* @version 0.1
* @brief Singleton
*/
#include <cassert>
#ifndef EXPORT_H
#define EXPORT_H
#define Export _declspec(dllexport)
#endif
#ifndef _SINGLETON_H__
#define _SINGLETON_H__

template <typename T>  class Singleton
{
    protected:
        static T* ms_Singleton;
    public:
        Singleton( void )
        {
             assert( !ms_Singleton );

//vc编译器
#if defined( _MSC_VER ) && _MSC_VER < 1200
            int offset = (int)(T*)1 - (int)(Singleton <T>*)(T*)1;
            ms_Singleton = (T*)((int)this + offset);
#else
             ms_Singleton = static_cast<T*>( this );
#endif
        }
        ~Singleton( void )
        { assert( ms_Singleton );  ms_Singleton = 0;  }
        static T& getSingleton( void )
        {
            assert( ms_Singleton );
            return ( *ms_Singleton );
        }
        static T* getSingletonPtr( void )
        { return ms_Singleton; }
};

#endif

本文链接

内存数据库内核开发工作日志（内存索引实现原理）（附红黑树实现清晰完整直接可编译运行代码）(十)

2011-06-23T12:13:00Z

这里回到文章主目录 [置顶]内存数据库内核开发探索

   之前由于考虑到使用Page的内存和磁盘互换的机制实现了B-tree做为数据库的键值索引，在真实的生产环境下2000万以上的数据建立索引会使到B-tree层数增多，效率明显下降，在运算工程中使用AIX大型机都用了数天才将2000多万的数据生成出来，效果非常不理想。
   全新的框架采用了纯内存的红黑树作为数据的索引，效果很好，性能测试中，用thinkpad 201i 电脑建立1000万的红黑树只用了3分钟，消耗内存270M这在电信项目的生产环境是完全可以接受的。
   该代码使用内存池和红黑树的技术，参考主要文献包括：
   http://zh.wikipedia.org/zh/%E7%BA%A2%E9%BB%91%E6%A0%91 维基百科
   IBM文章，http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html
   当然网上许多人的实现也给了我很好的启示，恕在下不能一一列出。
   也许你会说，不就实现了STL MAP的功能吗？可以这么说，因为内存中建立数据结构，红黑树是最优的方案，我只能使用这样的---像map一样的东西。
   以下是大致实现代码的思路，使用内存池来存放两类数据，一类是存放红黑树节点的内存池，一类是存放键值节点的内存池。

实例代码并不是用于项目中的实现，而是呈现内存索引的DEMO,其中delete的实现我没有实现内存释放，读者可以自己添加,相信它是网上能找到的最好，最清晰的红黑树能直接编译并稳定使用的代码，网上文章的代码都有这样那样的问题，最后还是根据理论自己实现了。

很多朋友对于内存数据库开发Email给我不能一一回复很抱歉，希望代码对各位有帮助。

另外内存池的代码请参考我的另一篇文章，内存池的实现内存池完整实现代码及一些思考

//该代码参照维基百科提供http://zh.wikipedia.org/zh/%E7%BA%A2%E9%BB%91%E6%A0%91 提供理论基础，2010-2011年由 konyellin Email: konyel@163.com进行整理修改

#include <string>
#include "MemoryPool.h"

#define    RB_INT        0
#define    RB_FLOAR    1
#define    RB_CHAR     2

struct rb_node
{
    unsigned short  color;
#define    RB_RED        0
#define    RB_BLACK    1
    struct rb_node* right;
    struct rb_node* left;
    struct rb_node* parent;
    void* memoryblock;
    void* key;
};

class rb_tree{
public:
    rb_tree(unsigned short type);
   //search
   rb_node* rb_search(void* key);
   void  rb_insert(void* key);
   rb_node*  rb_delete(void* key);
   //debug
   void print_tree(struct rb_node* root,int nLayer);

   struct rb_node* root;

private:
   MemoryPool* pool;
   unsigned short datetype;

   //insert case
   void __insert_case1(struct rb_node* n);
   void __insert_case2(struct rb_node* n);
   void __insert_case3(struct rb_node* n);
   void __insert_case4(struct rb_node* n);
   void __insert_case5(struct rb_node* n);

   //delete case
   void __delete_case1(struct rb_node* n);
   void __delete_case2(struct rb_node* n);
   void __delete_case3(struct rb_node* n);
   void __delete_case4(struct rb_node* n);
   void __delete_case5(struct rb_node* n);
   void __delete_case6(struct rb_node* n);

   //rotate
   void __rotate_left(struct rb_node *node);
   void __rotate_right(struct rb_node *node);
   void __replace_node(struct rb_node* node ,struct rb_node*  child);
   bool __is_leaf(struct rb_node* n);

   //查户口
   rb_node* __grandparent(struct rb_node* n);
   rb_node* __uncle(struct rb_node* n);
   rb_node* __sibling(struct rb_node* n);

   //比较键值查询
   int __rb_cmpkey(void* key1,void* key2);

   rb_node* __createnode(void* key);
};

#include "Rbtree.h"

rb_tree::rb_tree(unsigned short type):datetype(type){
   root=NULL;
   pool=new MemoryPool(sizeof(rb_node));
}

/*-----------------------------------------------------------
|   node           right
|   / \    ==>     / \
|   a  right     node  y
|       / \       / \
|       b  y     a   b    //左旋
-----------------------------------------------------------*/
rb_node* rb_tree::rb_search(void* key){
  struct rb_node* fnode=root;
  bool iskey=true;int ret=0;
  while(ret=__rb_cmpkey(fnode->key,key)){
      if(__is_leaf(fnode)){
         iskey=0;
         break;
      }
      if(ret>0)
            fnode=fnode->right;
      else
            fnode=fnode->left;

  }
  if(iskey)
    return fnode;
  else
    return NULL;
}

void rb_tree::__rotate_left(struct rb_node *node){
  rb_node* right = node->right;                   //指定指针指向 right<--node->right
    if ((node->right = right->left))
        right->left->parent = node;                 //好比上面的注释图，node成为b的父母
    right->left = node;                             //node成为right的左孩子
    if ((right->parent = node->parent)) {           //如果node根节点为空，node本身为根节点
        if (node == node->parent->right)            //如果node为右节点
            node->parent->right = right;
        else
            node->parent->left = right;
    }
    else
        root = right;
    node->parent = right;                           //right成为node的父母
}

void rb_tree::__rotate_right(struct rb_node *node){
    rb_node* left = node->left;
    if ((node->left = left->right))
        left->right->parent = node;
    left->right = node;
    if ((left->parent = node->parent)){
        if (node == node->parent->right)
            node->parent->right = left;
        else
            node->parent->left = left;
    }
    else
        root = left;
    node->parent = left;
}

rb_node* rb_tree::__grandparent(struct rb_node* n) {
   if(n->parent==NULL)
       return NULL;
   return n->parent->parent;
}
rb_node* rb_tree::__uncle(struct rb_node* n) {
    if(__grandparent(n)==NULL)
        return NULL;
    if (n->parent == __grandparent(n)->left)
    return __grandparent(n)->right;
    else
    return __grandparent(n)->left;
}

rb_node* rb_tree::__sibling(struct rb_node* n){
    if (n == n->parent->left)
    return n->parent->right;
    else
    return n->parent->left;
}

void rb_tree::__replace_node(struct rb_node* n, struct rb_node* child){
    child->memoryblock=n->memoryblock;
    child->key=n->key;
}
rb_node* rb_tree::__createnode(void* key){
       struct rb_node* node=(rb_node*)pool->Alloc();
       memset(node,0x00,sizeof(rb_node));
       node->key=key;
       node->color=RB_RED;
       return node;
}

bool rb_tree::__is_leaf(struct rb_node* n){
    if(n->left==NULL&&n->right==NULL)
        return true;
    return false;
}
int rb_tree::__rb_cmpkey(void* key1,void* key2){
    switch(datetype){
       case RB_INT:{
            if(*((int*)key1)<*((int*)key2))
              return -1;
            else if(*((int*)key1)>*((int*)key2))
              return 1;
            else
              return 0;
            break;
            }
       case RB_FLOAR:{
            if(*((float*)key1)<*((float*)key2))
                  return -1;
                else if(*((float*)key1)>*((float*)key2))
                  return 1;
                else
                  return 0;
                break;
            }
       case RB_CHAR:{
            char* s1=(char*)key1;char* s2=(char*)key1;
            return strcmp(s1,s2);
            break;
            }
    }
    return 0;
}
//按树状打印的二叉树
void rb_tree::print_tree(struct rb_node* root,int nLayer)
{
    if(root==NULL)
        return ;
    print_tree(root->right,nLayer+1);
    for(int i=0;i<nLayer;i++){
       printf("   ");
    }
    printf("%d-%d\n",*(int*)root->key,root->color);
    print_tree(root->left,nLayer+1);
}

#include "Rbtree.h"

//如果插入为根节点
void rb_tree::__insert_case1(struct rb_node* n){
    if (n->parent == NULL){
        n->color = RB_BLACK;
    }
    else
    __insert_case2(n);
}

void rb_tree::__insert_case2(struct rb_node* n){
   if (!(n->parent->color == RB_BLACK))
   __insert_case3(n);
}
//叔叔为红色节点的情况
void rb_tree::__insert_case3(struct rb_node* n){
    if (__uncle(n) != NULL && __uncle(n)->color == RB_RED) {
        n->parent->color = RB_BLACK;
        __uncle(n)->color = RB_BLACK;
        __grandparent(n)->color = RB_RED;
        __insert_case1(__grandparent(n));
    }
    else{
        __insert_case4(n);
    }
}

void rb_tree::__insert_case4(struct rb_node* n) {
    if (n == n->parent->right && n->parent == __grandparent(n)->left) {
        __rotate_left(n->parent);
        n = n->left;
    } else if (n == n->parent->left && n->parent == __grandparent(n)->right) {
        __rotate_right(n->parent);
        n = n->right;
    }
    __insert_case5(n);
}

void rb_tree::__insert_case5(struct rb_node* n) {
    n->parent->color = RB_BLACK;
    __grandparent(n)->color = RB_RED;
    if (n == n->parent->left && n->parent == __grandparent(n)->left) {
        __rotate_right(__grandparent(n));
    } else {
        __rotate_left(__grandparent(n));
   }
}

void rb_tree::rb_insert(void* key){
    struct rb_node* addnode = __createnode(key);
    //为空树的情况，创建根节点
    if(root==NULL){
         root=addnode;
         //根节点染黑
         root->color=RB_BLACK;
         return;
    }
    struct rb_node* fnode=root;
    int ret=0;
    while(ret=__rb_cmpkey(fnode->key,key)){
        if(__is_leaf(fnode)){
            if(ret>0){
                fnode->right=addnode;
                addnode->parent=fnode;
            }
            else{
                fnode->left=addnode;
                addnode->parent=fnode;
            }
            break;
        }
        if(ret>0)
            fnode=fnode->right;
        else
            fnode=fnode->left;
    }
    __insert_case1(addnode);
}

//Rbtree_Delete.cpp by konyel
#include "Rbtree.h"

void rb_tree::__delete_case1(struct rb_node* n){
    if (n->parent != NULL)
    __delete_case2(n);
}

void rb_tree::__delete_case2(struct rb_node* n)
{
    struct rb_node* s = __sibling(n);
    if (s->color == RB_RED) {
        n->parent->color = RB_RED;
        s->color = RB_BLACK;
        if (n == n->parent->left)
        __rotate_left(n->parent);
        else
        __rotate_right(n->parent);
    }
    __delete_case3(n);
}

void rb_tree::__delete_case3(struct rb_node* n){
    struct rb_node* s = __sibling(n);
    if ((n->parent->color == RB_BLACK) &&
    (s->color == RB_BLACK) &&
    (s->left==NULL||s->left->color == RB_BLACK) &&
    (s->right==NULL||s->right->color == RB_BLACK)) {
        s->color = RB_RED;
        __delete_case1(n->parent);
    } else
    __delete_case4(n);
}

void rb_tree::__delete_case4(struct rb_node* n){
    struct rb_node* s = __sibling(n);
    if ((n->parent->color == RB_RED) &&
    (s->color == RB_BLACK) &&
    (s->left==NULL||s->left->color == RB_BLACK) &&
    (s->right==NULL||s->right->color == RB_BLACK)) {
            s->color = RB_RED;
            n->parent->color = RB_BLACK;
    } else
    __delete_case5(n);
}

void rb_tree::__delete_case5(struct rb_node* n){
    struct rb_node* s = __sibling(n);
    if (s->color == RB_BLACK) {/* this if statement is trivial,
        due to Case 2 (even though Case two changed the sibling to a sibling's child,
        the sibling's child can't be red, since no red parent can have a red child). */
        // the following statements just force the red to be on the left of the left of the parent,
        // or right of the right, so case six will rotate correctly.
        if ((n == n->parent->left) &&
        (s->right->color == RB_BLACK) &&
        (s->left->color == RB_RED)) { // this last test is trivial too due to cases 2-4.
            s->color = RB_RED;
            s->left->color = RB_BLACK;
            __rotate_right(s);
            } else if ((n == n->parent->right) &&
            (s->left->color == RB_BLACK) &&
            (s->right->color == RB_RED)) {// this last test is trivial too due to cases 2-4.
                s->color = RB_RED;
                s->right->color = RB_BLACK;
                __rotate_left(s);
            }
    }
    __delete_case6(n);
}

void rb_tree::__delete_case6(struct rb_node* n){
    struct rb_node* s = __sibling(n);
    s->color = n->parent->color;
    n->parent->color = RB_BLACK;
    if (n == n->parent->left) {
        s->right->color = RB_BLACK;
        __rotate_left(n->parent);
    } else {
        s->left->color = RB_BLACK;
        __rotate_right(n->parent);
    }
}
rb_node* rb_tree::rb_delete(void* key){
    //两边都不是叶子节点
    struct rb_node* min_node;
    struct rb_node* fnode=root;
    int ret=0;
    while(ret=__rb_cmpkey(fnode->key,key)){
         if(__is_leaf(fnode)){
           return NULL;
         }
         if(ret>0)
             fnode=fnode->right;
         else
             fnode=fnode->left;
    }
    if(fnode->right!=NULL){
          min_node=fnode->right;
          while(min_node->left!=NULL)
              min_node=min_node->left;
    }
    else if(fnode->left!=NULL){
        min_node=fnode->left;
        while(min_node->right!=NULL)
              min_node=min_node->right;
    }
    else{
        min_node=fnode;
    }

    __replace_node(fnode, min_node);
    //用非叶子节点替换要删除的节点
    if (fnode->color == RB_BLACK) {
        if (min_node->color == RB_RED)
            min_node->color = RB_BLACK;
        else
            __delete_case1(min_node);
    }
    if(!__is_leaf(min_node)){
       return NULL;
    }
    if(min_node==root)
        root==NULL;
    else if(min_node->parent->right==min_node)
        min_node->parent->right=NULL;
    else
        min_node->parent->left=NULL;
    pool->Free(min_node);
    return NULL;
}

本文链接

内存池完整实现代码及一些思考

2011-06-06T07:05:00Z

为了提高效率和有效的监控内存的实时状态，我们采取了内存池的思想来解决效率与对内存实现监控的问题。

网上查找到了一些方案，根据自己的理解实现了应用。

我们什么时候要调用到内存池，

1，当我们频繁的申请释放同样数据大小的内存空间，我们可以用比动态new更有效方式来管理内存时，我们应该用内存池来提高效率。

2，当我们需要知道内存实时的申请状态，以便于对于服务器内存状态做实时预警时，我们可以用内存池的接口，来给内存增加监控。

实现的特点：

1，内存池内存单元大小可以动态定义，实现多级内存池。

2，申请效率很高，单元测试下是普通new/delete的4倍左右，当然具体性能还应机器类别而异。

MemoryPool.h 的实现

//该内存池理论来自于IBM文章，http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html
//作者冯宏华，徐莹，程远，汪磊享有论文著作权，由2011-06-06 konyel lin根据相关代码和理论进行优化修改。

#include <string>
#include <malloc.h>
//内存对齐值，可以根据机器取指长度进行设置
#define MEMPOOL_ALIGNMENT 4

#define USHORT unsigned short
#define ULONG unsigned long

struct MemoryBlock
{
USHORT nSize;
USHORT nFree;
USHORT nFirst;
USHORT nDummyAlign1;
MemoryBlock* pNext;
char aData[1];
static void* operator new(size_t,USHORT nTypes, USHORT nUnitSize){
     return ::operator new(sizeof(MemoryBlock) + nTypes * nUnitSize);
}
static void operator delete(void *p, size_t){
      ::operator delete (p);
}
MemoryBlock (USHORT nTypes = 1, USHORT nUnitSize = 0);
~MemoryBlock() {}
};

class MemoryPool
{
   private:
   MemoryBlock* pBlock;
   USHORT nUnitSize;
   USHORT nInitSize;
   USHORT nGrowSize;
   public:
   MemoryPool( USHORT nUnitSize,
   USHORT nInitSize = 1024,
   USHORT nGrowSize = 256 );
   ~MemoryPool();
   void* Alloc();
   void Free( void* p );
};

MemoryPool.cpp 的实现

#include "MemoryPool.h"

MemoryPool::MemoryPool( USHORT _nUnitSize,
USHORT _nInitSize, USHORT _nGrowSize )
{
pBlock = NULL;
nInitSize = _nInitSize;
nGrowSize = _nGrowSize;
if ( _nUnitSize > 4 )

nUnitSize = (_nUnitSize + (MEMPOOL_ALIGNMENT-1)) & ~(MEMPOOL_ALIGNMENT-1);
else if ( _nUnitSize <= 2 )
nUnitSize = 2;
else
nUnitSize = 4;
}

void* MemoryPool::Alloc()
{
MemoryBlock* pMyBlock;
if ( !pBlock ){
     //第一次调用初始化内存块
     pMyBlock =new(nGrowSize, nUnitSize) MemoryBlock(nGrowSize, nUnitSize);
   pBlock = pMyBlock;
      return (void*)(pMyBlock->aData);
}
pMyBlock = pBlock;
while (pMyBlock && !pMyBlock->nFree )
    pMyBlock = pMyBlock->pNext;
if ( pMyBlock ){
    printf("get a mem from block\n");
    char* pFree = pMyBlock->aData+(pMyBlock->nFirst*nUnitSize);
   //aData记录实际的内存单元标识
    pMyBlock->nFirst = *((USHORT*)pFree);
    pMyBlock->nFree--;
    return (void*)pFree;
}
else{
    printf("add a new block\n");
    if (!nGrowSize)
    return NULL;
    pMyBlock = new(nGrowSize, nUnitSize) MemoryBlock(nGrowSize, nUnitSize);
    if (!pMyBlock )
    return NULL;
    pMyBlock->pNext = pBlock;
    pBlock = pMyBlock;
    return (void*)(pMyBlock->aData);
}
}

void MemoryPool::Free( void* pFree ){
MemoryBlock* pMyBlock = pBlock;
MemoryBlock* preMyBlock;
//确定该待回收分配单元（pFree）落在哪一个内存块的指针范围内,大于起始节点，小于终止节点。
while ( ((ULONG)pMyBlock->aData > (ULONG)pFree) ||
((ULONG)pFree >= ((ULONG)pMyBlock->aData + pMyBlock->nSize))){
    //不在内存块范围内，则历遍下一个节点
    preMyBlock=pMyBlock;
    pMyBlock=pMyBlock->pNext;
}
pMyBlock->nFree++;
*((USHORT*)pFree) = pMyBlock->nFirst;
pMyBlock->nFirst = (USHORT)(((ULONG)pFree-(ULONG)(pBlock->aData)) / nUnitSize);
//判断内存块是否全部为自由状态，是则释放整个内存块
if (pMyBlock->nFree*nUnitSize == pMyBlock->nSize ){
     preMyBlock->pNext=pMyBlock->pNext;
   delete pMyBlock;
}
}

MemoryBlock::MemoryBlock (USHORT nTypes, USHORT nUnitSize)
: nSize (nTypes * nUnitSize),
   nFree (nTypes - 1),
nFirst (1),
pNext (0)
{
char * pData = aData;
for (USHORT i = 1; i < nTypes; i++) {
    //将内存块的前2个字节用来存放内存单元的标识
    *reinterpret_cast<USHORT*>(pData) = i;
    pData += nUnitSize;
}
}

本文链接

规则引擎处理海量数据实现工作日志(一）

2010-11-05T15:24:00Z

一，为什么我们要使用规则引擎

在电信行业中，我们做的最多的工作是在比较数据，话单的海量数据处理，无非就是将数据比较，去重，入库，汇总。为了在有限时间内实现数千万话单的逻辑，我们一遍一遍的用C实现简单教科书重复了一遍一遍的算法，list，tree，hash，几乎一个业务就衍生出一个独立程序。

所以我们看到我们的业务支撑上的服务器上，基本就是进程管理器，加一堆杂乱无章的独立程序，构成我们的系统。

我们在想，我们能不能用数据库，内存数据库，文件数据库，把话单变成能用Sql解析的数据，我们只用动态sql，去处理任意的数据形式，去重，汇总，比对，完成所有c程序要完成的工作。

1，我们应该怎么使用数据库来实现，我们能不能用Oracle生产库，能不能用TimesTen。

不能，使用Oracle,TimesTen会加大我们项目的预算，使我们的项目用很赚钱，变成赚一点钱的项目，要在我们所有业务支撑系统中推广，每一个实例30W$东西我们坚决不用，所以数据库的机制由我们自己实现，那么必须是开源的，可改造的。

2，我们自己实现的数据库，有什么技术需求，他与普通的数据库用什么区别。

*我们在计费，账务过分的依赖于共享内存，它必须小心的使用，因为你如果将未知大小销账列表都装进内存，当系统迅速吃光所有服务器的内存时，我们只好等着工程人员骂着娘帮我们重启机器。

用了数据库来运行就不一样了，当我们设定一个地市的pagecache是5G是，那么20个地市就是100G，消耗资源的大小是我们心中有数的。

*我们需要将千万级以上的数据快速的转换成B-tree的数据结构，我们不能忍受我们入库Oracle是每秒几千条入库效率，由话单文件，生成数十G数据库文件必须在二十分钟以内。

*转换后的文件形式不能过分的膨胀，XX省移动的话单在300G左右，我们不能再转换后将其变成几个T的容量，那样会使到我们又必须拉下面子求客户买机器。

*数据库索引的建立必须是快速的，自发的，能够依照我们sql里的条件，自动的创建需要的索引，由于他不是在线数据库，那么我们不用当心建立索引后，数据操作过慢的问题。我们是在所有数据转换成B-tree后，根据sql批量的建立我们需要的索引。

*业务对应的逻辑的实体，我们称之为规则RULE。

*规则可以拆分成可重用的逻辑粒度，我们称之为规则细项RULEITEM

*多个sql处理逻辑的过程我们称之为处理逻辑handle

*以上这些特征，我们称之为规则引擎。

*最后一点是，我们不需要再养一大批c算法高手了，业务人员根据业务的需要制定对应的SQL，我们的规则引擎自动帮我们处理数以亿万级的数据。

目前该方案已经在支撑系统的一个子系统中慢慢成形，数据量在千万级以上，并用于日常生产环境中，极大的降低开发成本，想与各位行业内外探讨下方案，

该方案是否与数据挖掘和数据仓库学科有共通的地方，这个可以请BI或NCR的朋友看看？

除了电信，金融以外行业，海量数据处理对于游戏，网站等其他行业有无相关需求？

再来是介绍我们实现这个方案的技术背景。

一，我们要先弄懂我们怎么去写这样一个规则引擎数据库。

我们先通过一个个问题来探讨什么是数据库，他是怎么实现的。有人说软件科学最精美方向有3个方向，操作系统，数据库，编译器。我们现在朝着其中一个去探究，看看前边有什么绮丽的风景。

我在这里先简单介绍下我所理解的数据内核，

1，数据库是怎么读懂Sql，为什么数据库能将Sql自动转化为高效的算法。

2，为什么数据库能用有限的内存处理无限外存数据，数据库怎么处理内存与外存的交换关系。

3， Page是什么东西，B-tree与Page是怎么联系起来的。

4， Index是什么东西，它是怎么添加上去的，为什么加上它sql就查的特别快。

本文链接

基于文件数据库的规则引擎处理海量高复杂度数据（二，解决方案）

2010-10-27T14:07:00Z

注本文为原创文章，作者konyel享有著作权，欢迎转载，请注明出处和原文地址。

本文链接

基于文件数据库的规则引擎处理海量高复杂度数据（一，业务背景）

2010-10-27T13:57:00Z

注本文为原创文章，作者konyel享有著作权，欢迎转载，请注明出处和原文地址。

本文链接

QQREADERC0DE2DE38D506198

2010-05-08T06:49:00Z

QQREADERC0DE2DE38D506198

内存数据库内核开发工作日志（innodb的原理，算法详细剖析）(九)

2009-07-09T02:06:00Z

内存数据库内核开发工作日志（innodb的原理，算法详细剖析）(九) 几个星期来一直在数据库文档的大海中浸泡，突然发现我还是没能深入到数据库内核开发的真正核心，始终停留在sqlite这个简单的框架无法突破,我需要重新思考一个新的切入点，最开始研究SQLite数据库，收获是数据库引擎开发的基本原理，虚拟机，代码生成，B-tree的各种算法，但当我考虑拓展其功能时我傻眼了，我没有一种专业的手法去扩展...

内存数据库内核开发探索

2009-06-30T03:26:00Z

许多人听到内存数据库第一印象就是大型的电信企业，银行的解决方案，但其实内存数据的应用相当广泛，从中型网站并发到批量文件处理都可以有很有效的应用。在商业领域的内存数据库主要ALTIBASE,与Oracle，TimesTen，但其昂贵的授权费（数十万$）令许多普通用户望而却步。在这里希望能整合在自身对数据处理业务的，开发并商业化一款面向普通用户的内存数据库，整合文件数据处理，和数据库数据处理，并发高效率处理的内存数据库解决方案。而开发我们数据库的方向，当然不在于与有十多年根基的TimesTen们竞争，在于开发一款拥有基本功能，具备二次开发的价值的内存数据处理软件，并提供在批量数据处理，

GUN详解

2008-05-07T09:06:00Z

1.gcc包含的c/c++编译器gcc,cc,c++,g++,gcc和cc是一样的，c++和g++是一样的。一般c程序就用gcc编译，c++程序就用g++编译。2.gcc的基本用法gcc test.c这样将编译出一个名为a.out的程序gcc test.c -o test这样将编译出一个名为test的程序，-o参数用来指定生成程序的名字 3.为什么会出现undefined reference to...

博客园_明论

单体模式实现代码

内存数据库内核开发 工作日志（内存索引实现原理）（附红黑树实现清晰完整直接可编译运行代码）(十)

内存池完整实现代码及一些思考

规则引擎处理海量数据实现工作日志(一）

基于文件数据库的规则引擎处理海量高复杂度数据（二，解决方案）

基于文件数据库的规则引擎处理海量高复杂度数据（一，业务背景）

QQREADERC0DE2DE38D506198

内存数据库内核开发 工作日志（innodb的原理，算法详细剖析）(九)

内存数据库内核开发探索

GUN详解

内存数据库内核开发工作日志（内存索引实现原理）（附红黑树实现清晰完整直接可编译运行代码）(十)

内存数据库内核开发工作日志（innodb的原理，算法详细剖析）(九)