Boost Shared Pointers to the Rescue!
Once again, I have found a perfect use for the boost::shared_ptr, and it's saved me a tons of grief. I've been working to refactor the exchange feed recorders and as I've been doing this, I starting getting stability problems in my StringPool class. Basically, I have a simple class that has an alloc() method that returns a (std::string *), and then allows you to recycle them when you are done with them. It's used in the exchange feeds, but I've been having issues when moving to the new format of append writing in the recorders.
So what to do?
Well… really, the problem is simple. I have a buffer that I fill, and rather than passing that to a write thread, and getting another, why don't we create a copy of what we have, clear out what we're using and just start over? The copy operation isn't bad, and if we use the boost::shared_ptr, we don't have to worry about it going out of scope on me, and it's easy to pass into the thread.
It's just about as clean as I can imagine. Simple. Clean. Get rid of the StringPool, have just a std::string and then when ready to fire off the write, make a new string smart pointer and use it. Sweet.
block->pack(buff); if ((buff.size() >= HIGH_WATER_MARK) || ((block->when > (lastSaved + saveInt)) && (buff.size() > 0))) { // grab the last saved time for the next interval lastSaved = block->when; // get the timestamp for the Beginning Of Buffer… uint64_t bob; memcpy(&bob, buff.data(), sizeof(bob)); // now let's fire off the thread and write this out… boost::shared_ptr<std::string> done(new std::string(buff)); boost::thread go = boost::thread(&UDPExchangeRecorder::write, this, bob, block->when, done, isPreferred(aConnection)); go.detach(); // clear out the buffer that we're using… buff.clear(); }
and then in the write method, it's very easy to use:
void UDPExchangeRecorder::write( uint64_t aStartTime, uint64_t anEndTime, boost::shared_ptr<std::string> aBuffer, bool aMaster ) { // make sure we have something to do… if (aBuffer->empty()) { return; } ... }
When the write method is done, the shared pointers will be dropped, and the memory freed. Easy, clean, and very stable. This cleared up all my issues.