第3月第2天 find symbolicatecrash 生产者－消费者 ice 引用计数

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

1.linux find export

find /Applications/Xcode.app/ -name symbolicatecrash -type f

export DEVELOPER_DIR="/Applications/Xcode.app/Contents/Developer"

2.symbolicatecrash

http://www.cnblogs.com/ningxu-ios/p/4141783.html

3.AURenderCallbackStruct

AURenderCallbackStruct callbackStruct;
callbackStruct.inputProc = AudioPlayUnit_context::playbackCallback;
callbackStruct.inputProcRefCon = this;

4.生产者－消费者

1）缓冲区,缓冲区写满需等待，消费者消费后需通知

class BytesBuffer : public IceUtil::Shared
{
public:
BytesBuffer(size_t bufferSize);
void feed(size_t size, BufferChunkRef cbChunk);
void eat(size_t size, BufferChunkRef cbChunk);

等待

void BytesBuffer_context::feed(size_t size, BufferChunkRef cbChunk)
{
{
Monitor<RecMutex>::Lock lock(_monitor);
if (_feedTerminated) return; while( size > _feedCapacity && !_eatTerminated) {
_currentFeedRequestSize = size;
// SP::printf("\nwait feeding, eatting %s\n", _eatTerminated ? "terminated" : "not terminated");
_monitor.wait();
}
_currentFeedRequestSize = ;
}

通知

Monitor<RecMutex>::Lock lock(_monitor);
//check and notify, if _feedTerminated then _currentFeedRequestSize=0, verify already included
if (_feedCapacity < _currentFeedRequestSize && _feedCapacity + size >= _currentFeedRequestSize)
_monitor.notify();

2）生产者

DecoderFileThread::DecoderFileThread(const char* path, BytesBufferPtr buffer)
: filepath(path)
, _buffer(buffer)
, _destroy(false)
, _decodeState(), file()
{
_cbChunk._userData = this;
_cbChunk._callback = DecoderFileThread::feedCallback;
}void DecoderFileThread::run()
{
_decodeState = Decoder_Interface_init();
file = fopen(filepath.c_str(), "rb");
fseek(file, , );
do {
_buffer->feed(*, &_cbChunk);
} while (!_destroy);
Decoder_Interface_exit(_decodeState);
fclose(file);
//SP::printf("\nfinish decode file\n");
}

3）消费者

OSStatus AudioPlayUnit_context::playbackCallback(void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData) {
#if !TEST
// Notes: ioData contains buffers (may be more than one!)
// Fill them up as much as you can. Remember to set the size value in each buffer to match how
// much data is in the buffer.
AudioPlayUnit_context* This = (AudioPlayUnit_context*)inRefCon; RenderChunk cbchunk = {};
cbchunk.inRefCon = This;
cbchunk.ioActionFlags = ioActionFlags;
cbchunk.inTimeStamp = inTimeStamp;
cbchunk.inBusNumber = inBusNumber;
cbchunk.inNumberFrames = inNumberFrames;
cbchunk.ioData = ioData; BufferChunk chunk;
chunk._callback = AudioPlayUnit_context::eatCallback;
chunk._userData = &cbchunk;
This->_buffer->eat(inNumberFrames*This->_audioFormat.mBytesPerFrame, &chunk); static size_t expired = ;
static IceUtil::Time lasttime;
if(This->_renderstartTimestamp == )
{
This->_renderstartTimestamp = IceUtil::Time::now().toMilliSeconds();
expired = ;
}
else
expired = IceUtil::Time::now().toMilliSeconds() - This->_renderstartTimestamp; if (This->_listenerPtr.get()) This->_listenerPtr->progress(This->_listenerPtr->userData, expired);
return noErr;
#else AudioPlayUnit_context* This = (AudioPlayUnit_context*)inRefCon;
static size_t pos = ;
ioData->mBuffers[].mData = This->_filebuffer + pos;
pos += inNumberFrames*;
//bytes2HexS((unsigned char*)ioData->mBuffers[0].mData, inNumberFrames*2);
return noErr;
#endif
}

5.ice

unix网络编程(卷2)7.3小节描述了生产者－消费者问题，7.5小节描述了条件变量

iceutil的monitor就是cpp的封装实现。

//
// This monitor implements the Mesa monitor semantics. That is any
// calls to notify() or notifyAll() are delayed until the monitor is
// unlocked.
//
template <class T>
class Monitor
{

6.引用计数

objective-c的引用计数很好理解，[[xx alloc] init]引用计数为1，retain引用计数加1，release引用计数减1，当引用计数为0时销毁内存。

ice的IceUtil::Shared包含了引用计数加1减1，但IceUtil::Shared在构造函数和析构函数并不会改变引用计数。使用时是使用IceUtil::Handle对象，IceUtil::Handle包含一个_ptr，构造函数如果参数为空，_prt置为null。如果构造函数的参数不为空，就会将_prt的引用计数加1，this->_ptr->__incRef()，析构函数会将_ptr的引用计数减1，this->_ptr->__decRef()。decRef函数判断引用计数为0时销毁内存。

IceUtril::Handle的拷贝构造函数和赋值函数也是将_ptr引用计数加1.因此有多个IceHandle包含同一个IceUtil::Shared，将IceUtil::Shared的引用计数加加减减。

IceUtil::Shared是用户自己new出来的，默认的引用计数为0，使用IceUtil::Handle时才会改变_ptr引用计数的值。

ace的ACE_Refcounted_Auto_Ptr_Rep包含了引用计数，内部包括一个auto_ptr的ptr_对象,构造函数会创建ptr_对象，析构时ptr_对象也会自动销毁，auto_ptr对象销毁时会释放new出来的内存。通过static函数attach，detach将引用计数加1减1，detach函数判断引用计数为0时销毁ACE_Refcounted_Auto_Ptr_Rep对象。

ace使用时是使用 ACE_Refcounted_Auto_Ptr，ACE_Refcounted_Auto_Ptr对象构造函数会创建ACE_Refcounted_Auto_Ptr_Rep对象rep_，析构函数会调用detach函数将rep_的引用计数减1.ACE_Refcounted_Auto_Ptr对象的拷贝构造函数和赋值函数也是将rep_引用计数加1.

因此有多个ACE_Refcounted_Auto_Ptr包含同一个ACE_Refcounted_Auto_Ptr_Rep，将ACE_Refcounted_Auto_Ptr_Rep的引用计数加加减减。

ACE_Refcounted_Auto_Ptr_Rep对象是ACE_Refcounted_Auto_Ptr对象构造函数创建的。使用ACE_Refcounted_Auto_Ptr时会改变rep_引用计数的值。

总结：

ace的ACE_Refcounted_Auto_Ptr不是很好理解，因为X *p并没有引用计数，所以需要封装一个ACE_Refcounted_Auto_Ptr_Rep对象，但ACE_Refcounted_Auto_Ptr_Rep对象又不是用户自己创建的，是构造函数自己创建的。而构造函数中又没有通过ACE_Refcounted_Auto_Ptr_Rep对象来创建，这样就隐藏了ACE_Refcounted_Auto_Ptr_Rep对象的存在，让人不好理解。

第一步，创建ACE_Refcounted_Auto_Ptr_Rep对象，第二步使用ACE_Refcounted_Auto_Ptr。ace不让用户一步步完成。构造函数是通过X *p创建ACE_Refcounted_Auto_Ptr_Rep对象，拷贝构造函数和赋值函数是通过const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r的rep_引用计数加1。

而ice 因此如果需要将一个对象申明智能指针，必须让其继承至IceUtil::Shared,就好理解一点。

iceutil::Shared

class ICE_UTIL_API Shared
{
public: Shared();
Shared(const Shared&); virtual ~Shared()
{
} Shared& operator=(const Shared&)
{
return *this;
} virtual void __incRef();
virtual void __decRef();
virtual int __getRef() const;
virtual void __setNoDelete(bool);protected:#if defined(_WIN32)
LONG _ref;
#elif defined(ICE_HAS_ATOMIC_FUNCTIONS) || defined(ICE_HAS_GCC_BUILTINS)
volatile int _ref;
#else
int _ref;
Mutex _mutex;
#endif
bool _noDelete;
};}

ace

template <class X, class ACE_LOCK> inline
ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (X *p)
: rep_ (AUTO_REFCOUNTED_PTR_REP::create (p))
{
}template <class X, class ACE_LOCK> inline
ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r)
: rep_ (AUTO_REFCOUNTED_PTR_REP::attach (((ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &) r).rep_))
{
}template <class X, class ACE_LOCK> inline void
ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator = (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &rhs)
{
// bind <this> to the same <ACE_Refcounted_Auto_Ptr_Rep> as <r>.
AUTO_REFCOUNTED_PTR_REP *old_rep = this->rep_;
if (rhs.rep_ != )
{
this->rep_ = AUTO_REFCOUNTED_PTR_REP::attach
(const_cast<ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>& > (rhs).rep_);
if (this->rep_ != )
AUTO_REFCOUNTED_PTR_REP::detach (old_rep);
}
else // Assign a 0 rep to this
{
AUTO_REFCOUNTED_PTR_REP::detach (old_rep);
this->rep_ = ;
}
}template <class X, class ACE_LOCK>
ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr (void)
{
AUTO_REFCOUNTED_PTR_REP::detach (rep_);
}