ACE_Message_Block实现浅析

  转载自：http://blog.csdn.net/ydogg/article/details/1818949#FeedBack

ACE_Message_Block实现浅析

1.     概述

ACE_Message_Block是ACE中很重要的一个类,和ACE框架中的重要模式的实现 如ACE_Reactor, ACE_Proactor, ACE_Stream, ACE_Task都有紧密的联系.

换个角度看,ACE_Message_Block实际上已经是这些实现中的重要组成部分.抛开和框架的配合不谈, ACE_Message_Block本身也相当有用,功能强大,用途广泛.ACE_Message_Block的实现中使用了很多技巧和模式,代表性的有GOF的composite模式.这让它在处理数据特别是网络数据时会很方便.而且, 在多线程开发中,它也可以充当线程之间传递的消息.

2.     ACE_Message_Block的特点

ACE_Message_Block有几个重要特性:

1.      ACE_Message_Block内部采用ACE_Data_Block来间接管理实际数据, 减轻了其它功能与实际内存管理之间的耦合.

2.      ACE_Message_Block采用了引用计数, 可以灵活高效的共享数据, 并降低了内存拷贝带来的额外开销.

实际上, ACE_Message_Block本身并没有reference count, 而是间接的由ACE_Data_Block来提供.

3.      允许多条消息连接起来,形成一个单向链表, 从而支持复合消息Composite模式).

由此,ACE_Message_Block提供了cont()方法.

4.      允许将多条消息连接起来,形成一个双链表. 为ACE_Message_Queue的实现提供了支持.

由此,ACE_Message_Block提供next()和prev()方法.

5.      集成将同步策略和内存管理策略, 使得无需修改底层代码就能改变ACE_Message_Block的运行特征.

 
下面是自己总结的, 一开始总是混淆和迷惑的地方, 需要注意:

6.      3)4)特性实际上是正交的, 不存在交叉和冲突. 单链表实现复合消息, 双链表实现消息队列; 前者重内部, 后者重外部. 换个角度来说, 就是消息队列中的消息可以是复合消息.

7.      ACE_Message_Block对内存空间的管理采用“谁申请谁释放”的策略.

在控制权转移时, 需要特别注意这一点.(空间的所有权可能会随size()方法的调用而转移)在使用外部的缓冲区构造ACE_Message_Block或者初始化时,需要特别注意.

3.     ACE_Message_Block的数据管理

前面已经说明, 处于减少耦合的原因,ACE_Message_Block并不直接管理实际数据,而是委托ACE_Data_Block进行管理.因此, 对ACE_Data_Block的很多函数都有包裹调用:如base(), end(), mark()等等.

虽然ACE_Data_Block的管理很高效,但是,总体来说ACE_Data_Block并不关注”数据的有效性”.ACE_Data_Block只是简单的对空间进行管理, 提供起始地址.就像一个普通buffer.

ACE_Message_Block弥补了ACE_Data_Block的不足, 提供了读指针和写指针(内部实现为游标). 这样,用户可以方便的进行连续读写,代表性的例子是ACE_Message_Block的copy()方法.也为多个ACE_Message_Block复用相同的ACE_Data_Block提供了良好的支持.

 
ACE_Data_Block有两种方式获取空间:

1)    自行申请空间

2)    使用用户提供的空间

如果没有设定DONT_DELETE标志, ACE_Data_Block还能自动替用户来释放所管理的空间.

当使用栈上的缓冲区初始ACE_Data_Block时,要特别注意保证缓冲区的有效性,防止ACE_Data_Block使用无效指针.

 4.     ACE_Message_Block的构造和初始化

ACE_Message_Block提供了7个构造函数和3个初始化函数, 在实现中, 这些函数都不过是内部函数

init_i()函数的一个包裹.

4.1     init_i()的参数

init_i的参数有11个,不过大部分构造函数中调用时都设定了默认值.

 

int  init_i (size_t size,
              ACE_Message_Type type,
              ACE_Message_Block  * cont,
               const   char   * data,
              ACE_Allocator  * allocator_strategy,
              ACE_Lock  * locking_strategy,
              Message_Flags flags,
              unsigned  long  priority,
               const  ACE_Time_Value  & execution_time,
               const  ACE_Time_Value  & deadline_time,
              ACE_Data_Block  * db,
              ACE_Allocator  * data_block_allocator,
              ACE_Allocator  * message_block_allocator);

参数	类型	用途说明
size	size_t	数据空间大小
type	ACE_Message_Type	消息类型
cont	ACE_Message_Block *	挂接其它MB以成为复合消息
data	const char *	data!=0 表示使用外部提供的空间 data==0 表示由ACE_Message_Block来分配所需空间
allocator_strategy	ACE_Allocator *	申请空间时, 使用的内存分配策略. data==0时使用. 默认值ACE_Allocator::instance()
locking_strategy	ACE_Lock *	多线程下的安全策略
Message_Flags	flags	MB属性,用于判断是否要释放内部的ACE_Data_Block 当data!=0时,默认设置为DONT_DELETE
priority	unsigned long	优先级,默认为0
excute_time	const ACE_Time_Value&	暂不使用
deadline_time	const ACE_Time_Value&	暂不使用
db	ACE_Data_Block *	使用外部提供的
data_block_allocator	ACE_Allocator *	ACE_Data_Block的分配策略. db==0时使用 默认值ACE_Allocator::instance()
message_block_allocator	ACE_Allocator *	ACE_Message_Block的分配策略. 默认值ACE_Allocator::instance()

 默认的ACE_Allocator::instance()返回ACE_New_Allocator类型的策略.

4.2     init_i()的实现

实现动作很简单, 主要是旧data_block的释放和再申请,至于用户要求的size大小的空间,则交由ACE_Data_Block去具体负责.

{
    this->rd_ptr_ = 0;
    this->wr_ptr_ = 0;
    this->priority_ = priority;
    this->cont_ = msg_cont;
    this->next_ = 0;
    this->prev_ = 0;
    this->message_block_allocator_ = message_block_allocator;

    if (this->data_block_ != 0)
    {
        this->data_block_->release ();
        this->data_block_ = 0;
    }

    if (db == 0)
    {
        if (data_block_allocator == 0)
        ACE_ALLOCATOR_RETURN (data_block_allocator,    ,  ACE_Allocator::instance (),    -1);

        ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_ALLOC);

        ACE_NEW_MALLOC_RETURN (db,
            static_cast<ACE_Data_Block *> (    data_block_allocator->malloc (sizeof (ACE_Data_Block))),
            ACE_Data_Block (size,
            msg_type,
            msg_data,
            allocator_strategy,
            locking_strategy,
            flags,
            data_block_allocator),
            -1);

        ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_CTOR);

        if (db != 0 && db->size () < size)
        {
            db->ACE_Data_Block::~ACE_Data_Block();
            data_block_allocator->free (db);
            errno = ENOMEM;
            return -1;
        }
    }

    this->data_block (db);
    return 0;
}

5.     ACE_Message_Block的析构和释放

ACE_Message_Block的在析构之外还单独具备了一个release()函数,各有用途,不能相互替代.

1) ACE_Message_Block的析构函数不关心单向链(复合消息)的处理,只是把自己本身清理干净.

2) release()是个递归函数, 它会通过cont()访问所有链接的ACE_Message_Block, 依次对其进行清理,然后最后清理自己本身.清理的方式是ACE_DES_FREE,类似于delete this,但不完全一样.

3) 还有一个静态的releas(ACE_Message_Block*)函数,功能是一样的

 由此也可以看出,在栈上生成的ACE_Message_Block,千万不能调用release(),否则会发生所谓的”fall off the stack”. 

ACE的注释:

    *  release()  is  designed to release the continuation chain; the
    *  destructor  is  not.  If we make the destructor release the
    *  continuation chain by calling release() or delete on the message
    *  blocks  in  the continuation chain, the following code will not
    *  work since the message block  in  the continuation chain  is  not off
    *  the heap:
    *
    *   ACE_Message_Block mb1 ( 1024 );
    *   ACE_Message_Block mb2 ( 1024 );
    *
    *   mb1.cont ( & mb2);
    *
    *  And hence, call release() on a dynamically allocated message
    *  block. This will release all the message blocks  in  the
    *  continuation chain.  If you call delete or let the message block
    *  fall off the stack, cleanup of the message blocks  in  the
    *  continuation chain becomes the responsibility of the user.

所以如果一定要在栈上生成 ACE_Message_Block, 那么只能自己手动的清理内部的单向链了 .

5.1     析构函数

析构函数很简单,主要是内部data_block的清理,注意是调用data_block()->release()

,因为ACE_Data_Block使用了引用计数.

 

ACE_Message_Block:: ~ ACE_Message_Block ( void )
{
    ACE_TRACE ("ACE_Message_Block::~ACE_Message_Block");
    if (ACE_BIT_DISABLED (this->flags_,  ACE_Message_Block::DONT_DELETE) &&  this->data_block ())
               this->data_block ()->release ();

  this->prev_ = 0;
  this->next_ = 0;
}

5.2     release()函数

  

ACE_Message_Block::release ( void )
{
  destroy_dblock = this->release_i (0);
  if (destroy_dblock != 0)
    {
      ACE_Allocator *allocator = tmp->data_block_allocator ();
      ACE_DES_FREE (tmp,
                    allocator->free,
                    ACE_Data_Block);
    }

  return 0;
}

这里省略了大部分线程策略处理,只保留了关键代码,可以看出,核心是release_i()函数.

int  ACE_Message_Block::release_i (ACE_Lock  * lock )
{
  // Free up all the continuation messages.
  if (this->cont_)
    {
      ACE_Message_Block *mb = this->cont_;
      ACE_Message_Block *tmp = 0;

      do
        {
          tmp = mb;
          mb = mb->cont_;
          tmp->cont_ = 0;

          ACE_Data_Block *db = tmp->data_block ();
          if (tmp->release_i (lock) != 0)
            {
              ACE_Allocator *allocator = db->data_block_allocator ();
              ACE_DES_FREE (db,
                            allocator->free,
                            ACE_Data_Block);
            }
        }
      while (mb);

      this->cont_ = 0;
    }

  int result = 0;

  if (ACE_BIT_DISABLED (this->flags_,
                        ACE_Message_Block::DONT_DELETE) &&
      this->data_block ())
    {
      if (this->data_block ()->release_no_delete (lock) == 0)
        result = 1;
      this->data_block_ = 0;
    }

  if (this->message_block_allocator_ == 0)
    delete this;
  else
    {
      ACE_Allocator *allocator = this->message_block_allocator_;
      ACE_DES_FREE (this,
                    allocator->free,
                    ACE_Message_Block);
    }

  return result;
}

处理也很清晰, 基本递归处理完所有的单链MB  

6.     ACE_Message_Block中容易混淆的几个函数

ACE_Message_Block中有多个获取大小或者长度的函数,容易混淆.
下图是根据ACE_Message_Block(实际是ACE_Data_Block)空间的处理状况所绘,能比较清晰的反应出它们的异同.
需要注意,为了表现出多样性,下图是wr_ptr(),rd_ptr(),size()都调用过之后的情景.

 红色表示是ACE_Message_Block独有的函数, 其余则ACE_Message_Block和ACE_Data_Block均有.
矩形纸上函数的返回值均为指针类型,之下的返回值均为size_t类型.
 

函数	说明
length()	有效数据的长度 == wr_ptr() – rd_ptr()
size()	全部可用空间的长度,如果没有size()而变小,则等同capacity() == mark() – base()
space()	剩余可用空间的长度 <= size() - length(),因为不含rd_ptr()移动过的空间 == mark() – wr_ptr()
capacity()	最大空间的长度(ACE_Message_Block构造或初始化时所用参数值) == end() – base()
total_length()	复合消息(ACE_Message_Block内单向链 cont())的总长度
total_size()	复合消息(ACE_Message_Block内单向链 cont())的总大小
total_capacity()	复合消息(ACE_Message_Block内单向链 cont())的总空间大小

 

7.     ACE_Message_Block常用函数简介

7.1     duplicate()

duplicate()浅拷贝函数,公用一个内部的ACE_Data_Block
ACE_Message_Block::duplicate() 与 ACE_Data_Block.duplicate()的实现是不同的.
ACE_Data_Block::duplicate()简单的只是将自身的reference加+1, 然后返回自身(this)
ACE_Message_Block:duplicate()则将自身copy了一份, 然后将自身的状态值赋给拷贝,注意它们公用同一个data_block.而且ACE_Message_Block::duplicate()支持复合消息,它会检查内部单向链,来依次调用其duplicate().

 这里ACE_Data_Block::duplicate()的函数行为很怪异,以后就能看出它怪异行为的影响.说实话,这个地方如此设计我很不理解,因为ACE_Data_Block本身其实已经有reference了.

7.2     clone()

ACE_Message_Block::clone()深拷贝, 不但拷贝自身,内部的ACE_Data_Block也一并拷贝了,并且支持复合消息.

7.3     size()

ACE_Data_Block.size(size_t len)函数, 动态的变化ACE_Data_Block持有的空间.
ACE_Message_Block.size(size_t len)函数是ACE_Data_Block.size(size_t len)的简单包裹.
如果len比现有的尺寸小, 简单的cur_size_ = length;
如果len比现有的尺寸大, 会申请新的空间并拷贝原所有数据.

注意! 这里可能会发生空间控制权的转换! 即标志位DONT_DELETE的变化.若原ACE_Data_Block使用托管空间, 则此时会更替为自己申请的空间,从而拥有了控制权, 所以此时要注意原有空间的管理.
对ACE_Message_Block和ACE_Data_Block, 除非主动调用size(), 否则它们不会自动申请和扩大空间.

7.4     其它函数

ACE_Message_Block::crunch() 将现有数据移动到现有的缓冲的开始.

ACE_Message_Block::reset()将现有读写指针赋为初始值(ACE_Data_Block.base())

ACE_Message_Block::base()是对ACE_Data_Block.base()的简单包裹

 8.     需要注意的地方

8.1     注意点1

1)ACE_Message_Block的构造函数中,如果data为NULL, 则ACE_Message_Block会为其自动分配空间. 但如data非NULL,则ACE_Message_Block会直接引用data指向的空间, 并不会进行新的空间分配和拷贝.

所以需要特别注意, 在ACE_Message_Block的实例没有销毁之前,不能释放data指向的空间.

 2)虽然ACE_Message_Block会根据size的值来更改自己的size(),但wr_ptr不会根据data的长度进行设置, 造成length()的返回为0.

需要特别注意, 当构造一个ACE_Message_Block实例后, 随之需要追加数据时,必须设置wr_ptr的值,否则原有数据将会被覆写.

 此时的含义是: ACE_Message_Block代管了data缓冲区,但不负责缓冲区的空间管理(因为也不是由它申请的).

8.2     注意点2

默认定义的flag: enum  { DONT_DELETE = 01, USER_FLAGS = 0x1000 }

1) set_flags()、clr_flags()是对ACE_Message_Block中的数据指针(ACE_Data_Block*)进行设置.

2) set_self_flags(),clr_self_flags()是对ACE_Message_Block本身进行设置.

8.3     注意点3

ACE_Message_Block::copy(const char* buf) 函数将字符串copy到ACE_Message_Block, 如果内在空间不足, 将会返回-1.

需要特别注意, copy的数据将包括末尾的0, 也就是copy的数据长度为strlen(buf)+1.

而且, 会自动进行wr_ptr()的设置

9.     ACE_Data_Block的思考

 ACE_Data_Block的析构函数是释放持有空间base_的惟一路径(size()的情况不讨论).

ACE_Data_Block中通过duplicate()递增引用计数. ACE_Data_Block中通过release()递减引用计数, 当引用计数为0时,先调用ACE_Data_Block析构函数,然后释放ACE_Data_Block自身.
注意, ACE_Data_Block的构造和析构函数都不知道引用计数的存在. 在构造函数中, 只是设置了初始值1.

 ACE_Data_Block一个很奇怪的地方就是ACE_Data_Block::duplicate()的实现, 并没有创建新的拷贝, 而仅仅是返回了自身(return this). 这中实现方式带来了很多奇怪的问题.如下面的2,3.
 release()-> release_no_delete()->release_i()->~ACE_Data_Block()

 如果在Stack上构造ACE_Data_Block,那么不能使用release()函数, 因为release()函数会试图删除this

 如果在stack上构造ACE_Data_Block, 那么不能使用duplicate()函数, 因为duplicate()返回的是this指针, 栈中的ACE_Data_Block析构后会导致问题.

 如果在heap上构造ACE_Data_Block,那么尽量使用release()来替代delete, 如果存在因为析构并不处理reference count, delete时不考虑其它会导致指针悬空.