ACE_Data_Block的内存泄漏，请大家指教！

peakzhang

看了ACE5.5的ACE_Message_Block和ACE_Data_Block代码，觉得有内存泄漏问题。
对下面的ACE_Message_Block构函，如果data为0(null),ACE_Message_Block
的flags_标志为0（故ACE_Data_Block的引用计数为0时将调用ACE_Data_Block的析构函数）；
ACE_Data_Block标志为ACE_Message_Block::DONT_DELETE；
在ACE_Data_Block的构函中会调用ACE_ALLOCATOR (this->base_,
                   (char *) this->allocator_strategy_->malloc (size)); 为base_分配内存
                  
但在ACE_Data_Block的析构函数中，由于ACE_Data_Block标志为ACE_Message_Block::DONT_DELETE，
故不会释放base_的内存！
                  
   相关代码如下：               

2. ACE_Message_Block::ACE_Message_Block (const char *data,
3.                                       size_t size,
4.                                       unsigned long priority)
5.   : flags_ (0),
6.     data_block_ (0)
7. {
8.   ACE_TRACE ("ACE_Message_Block::ACE_Message_Block");
10.   if (this->init_i (size,    // size
11.                     MB_DATA, // type
12.                     0,       // cont
13.                     data,    // data  =null
14.                     0,       // allocator
15.                     0,       // locking strategy
16.                     ACE_Message_Block::DONT_DELETE, // flags   
17.                     priority, // priority
18.                     ACE_Time_Value::zero,     // execution time
19.                     ACE_Time_Value::max_time, // absolute time of deadline
20.                     0,  // data block
21.                     0,  // data_block allocator
22.                     0) == -1) // message_block allocator
23.     ACE_ERROR ((LM_ERROR,
24.                 ACE_LIB_TEXT ("ACE_Message_Block")));
25. }
28. ACE_Message_Block::init_i (size_t size,
29.                            ACE_Message_Type msg_type,
30.                            ACE_Message_Block *msg_cont,
31.                            const char *msg_data,
32.                            ACE_Allocator *allocator_strategy,
33.                            ACE_Lock *locking_strategy,
34.                            Message_Flags flags,
35.                            unsigned long priority,
36.                            const ACE_Time_Value &execution_time,
37.                            const ACE_Time_Value &deadline_time,
38.                            ACE_Data_Block *db,
39.                            ACE_Allocator *data_block_allocator,
40.                            ACE_Allocator *message_block_allocator)
41. {
42.   //...... 略去无关代码
43.   
44.   if (this->data_block_ != 0)
45.     {
46.       this->data_block_->release ();
47.       this->data_block_ = 0;
48.     }
50.   if (db == 0)
51.     {
52.       if (data_block_allocator == 0)
53.         ACE_ALLOCATOR_RETURN (data_block_allocator,
54.                               ACE_Allocator::instance (),
55.                               -1);
57.       ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_ALLOC);
59.       
60.       ACE_NEW_MALLOC_RETURN (db,
61.                              static_cast<ACE_Data_Block *> (
62.                                data_block_allocator->malloc (sizeof (ACE_Data_Block))),
63.                              ACE_Data_Block (size,
64.                                              msg_type,  
65.                                              msg_data,  // =null
66.                                              allocator_strategy,
67.                                              locking_strategy,
68.                                              flags, // =ACE_Message_Block::DONT_DELETE
69.                                              data_block_allocator),
70.                              -1);
71.       ACE_TIMEPROBE (ACE_MESSAGE_BLOCK_INIT_I_DB_CTOR);
72.     }
74.   // Reset the data_block_ pointer.
75.   this->data_block (db);
76.   // If the data alloc failed, the ACE_Data_Block ctor can't relay
77.   // that directly. Therefore, need to check it explicitly.
78.   if (db->size () < size)
79.     return -1;
80.   return 0;
81. }
84. ACE_Data_Block::ACE_Data_Block (size_t size,
85.                                 ACE_Message_Block::ACE_Message_Type msg_type,
86.                                 const char *msg_data,
87.                                 ACE_Allocator *allocator_strategy,
88.                                 ACE_Lock *locking_strategy,
89.                                 ACE_Message_Block::Message_Flags flags,
90.                                 ACE_Allocator *data_block_allocator)
91.   : type_ (msg_type),
92.     cur_size_ (0),          // Reset later if memory alloc'd ok
93.     max_size_ (0),
94.     flags_ (flags), // =ACE_Message_Block::DONT_DELETE
95.     base_ (const_cast <char *> (msg_data)), //base = 0
96.     allocator_strategy_ (allocator_strategy),
97.     locking_strategy_ (locking_strategy),
98.     reference_count_ (1),
99.     data_block_allocator_ (data_block_allocator)
100. {
101.   ACE_TRACE ("ACE_Data_Block::ACE_Data_Block");
102.   ACE_FUNCTION_TIMEPROBE (ACE_DATA_BLOCK_CTOR2_ENTER);
104.   // If the user didn't pass one in, let's use the
105.   // <ACE_Allocator::instance>.
106.   if (this->allocator_strategy_ == 0)
107.     ACE_ALLOCATOR (this->allocator_strategy_,
108.                    ACE_Allocator::instance ());
110.   if (this->data_block_allocator_ == 0)
111.     ACE_ALLOCATOR (this->data_block_allocator_,
112.                    ACE_Allocator::instance ());
114.   if (msg_data == 0)  // msg_data = 0,为base_分配内存
115.     ACE_ALLOCATOR (this->base_,
116.                    (char *) this->allocator_strategy_->malloc (size));
117.     // ACE_ALLOCATOR returns on alloc failure...
119.   // The memory is legit, whether passed in or allocated, so set the size.
120.   this->cur_size_ = this->max_size_ = size;
121. }
123. ACE_Data_Block::~ACE_Data_Block (void)
124. {
125.   // Sanity check...
126.   ACE_ASSERT (this->reference_count_ <= 1);
128.   // Just to be safe...
129.   this->reference_count_ = 0;
131.   if (ACE_BIT_DISABLED (this->flags_,
132.                         ACE_Message_Block::DONT_DELETE))     //this->flags_=ACE_Message_Block::DONT_DELETE
133.     {
134.       this->allocator_strategy_->free ((void *) this->base_); //不会执行该语句，base_指向的内存没有释放，泄漏！
135.       this->base_ = 0;
136.     }
137. }

复制代码

peakzhang

ACE_Message_Block的数据直接指向了参数中const char *data这块内存，这块内存不是由ACE_Message_Block创建的，所以不必释放。

peakzhang

不同意楼上的。是base_的内存泄漏，不是data。

在ACE_Data_Block的构函中有如下语句：

if (msg_data == 0)  // 此时 msg_data = 0,为base_分配内存
    ACE_ALLOCATOR (this->base_,
                   (char *) this->allocator_strategy_->malloc (size));
    // ACE_ALLOCATOR returns on alloc failure...

但在ACE_Data_Block的析构函数中，由于ACE_Data_Block标志为ACE_Message_Block::DONT_DELETE，
故不会释放base_的内存！

peakzhang

base_就是指向的data

ACE_Data_Block::ACE_Data_Block (size_t size,
                                ACE_Message_Block::ACE_Message_Type msg_type,
                                const char *msg_data,
                                ACE_Allocator *allocator_strategy,
                                ACE_Lock *locking_strategy,
                                ACE_Message_Block::Message_Flags flags,
                                ACE_Allocator *data_block_allocator)
  : type_ (msg_type),
    cur_size_ (0),          // Reset later if memory alloc'd ok
    max_size_ (0),
    flags_ (flags), // =ACE_Message_Block::DONT_DELETE
    base_ (const_cast <char *> (msg_data)), //base = 0
    allocator_strategy_ (allocator_strategy),
    locking_strategy_ (locking_strategy),
    reference_count_ (1),
    data_block_allocator_ (data_block_allocator)

peakzhang

在ACE_Data_Block的构函初始化列表中base_就是指向的data

//（base_ (const_cast <char *> (msg_data)), ）
但在构造函数体中有下列语句

if (msg_data == 0)  // msg_data = 0,为base_分配内存
    ACE_ALLOCATOR (this->base_,
                   (char *) this->allocator_strategy_->malloc (size));
这样如果data为空（也就是msg_data 为空），会重新为base_分配内存，此时base_和data

已经不一样了。

peakzhang

ACE_Message_Block::ACE_Message_Block (const char *data,
                                      size_t size,
                                      unsigned long priority)
data为空的话，size也应该为０啊, malloc(0)没事

peakzhang

如果是这样，就不会有问题了！但客户要遵守该约定：data为空，size也应该为０