/** Destroy the Buffer chain of a BufferedWriter
*
* \param self pointer to the BufferedWriter
*
* \return 0 on success, or a negative number otherwise
*/
int
destroyBufferChain(BufferedWriter* self) {
BufferChunk *chunk, *start;
if (!self) {
return -1;
}
/* BufferChunk is a circular buffer */
start = self->firstChunk;
while( (chunk = self->firstChunk) && chunk!=start) {
logdebug("Destroying BufferChunk at %p\n", chunk);
self->firstChunk = chunk->next;
mbuf_destroy(chunk->mbuf);
pthread_mutex_destroy(&chunk->lock);
oml_free(chunk);
}
mbuf_destroy(self->meta_buf);
mbuf_destroy(self->read_buf);
pthread_cond_destroy(&self->semaphore);
pthread_mutex_destroy(&self->meta_lock);
pthread_mutex_destroy(&self->lock);
return 0;
}
/** Initialise a BufferChunk for a BufferedWriter.
*
* \warning A lock on the BufferedWriter should be held if the readerThread
* has already been started.
*
* \param self BufferedWriter pointer
* \return a pointer to the newly-created BufferChunk, or NULL on error
*/
BufferChunk*
createBufferChunk(BufferedWriter* self)
{
size_t initsize = 0.1 * self->bufSize;
MBuffer* buf = mbuf_create2(self->bufSize, initsize);
if (buf == NULL) { return NULL; }
BufferChunk* chunk = (BufferChunk*)oml_malloc(sizeof(BufferChunk));
if (chunk == NULL) {
mbuf_destroy(buf);
return NULL;
}
memset(chunk, 0, sizeof(BufferChunk));
// set state
chunk->mbuf = buf;
chunk->targetBufSize = self->bufSize;
chunk->next = chunk;
pthread_mutex_init(&chunk->lock, NULL);
logdebug3("%s: initialised chunk mutex %p\n", self->outStream->dest, &chunk->lock);
self->unallocatedBuffers--;
logdebug("Allocated chunk of size %dB (up to %d), %d remaining\n",
initsize, self->bufSize, self->unallocatedBuffers);
return chunk;
}
BufferChain*
createBufferChain(
BufferedWriter* self
) {
// BufferChain* chain = (BufferChain*)malloc(sizeof(BufferChain) + self->chainLength);
MBuffer* buf = mbuf_create2(self->chainLength, (size_t)(0.1 * self->chainLength));
if (buf == NULL) return NULL;
BufferChain* chain = (BufferChain*)xmalloc(sizeof(BufferChain));
if (chain == NULL) {
mbuf_destroy(buf);
return NULL;
}
memset(chain, 0, sizeof(BufferChain));
// set state
chain->mbuf = buf;
chain->targetBufSize = self->chainLength;
/**
buf->writeP = buf->readP = &buf->buf;
buf->endP = &buf->buf + (buf->bufLength = self->chainLength);
*/
self->chainsAvailable--;
o_log (O_LOG_DEBUG, "Created new buffer chain of size %d with %d remaining.\n",
self->chainLength, self->chainsAvailable);
return chain;
}
/** Destroy the Buffer chain of a BufferedWriter
*
* \param self pointer to the BufferedWriter
* \return 0 on success, or a negative number otherwise
*/
int
destroyBufferChain(BufferedWriter* self) {
BufferChain *chain, *start;
if (!self)
return -1;
/* BufferChain is a circular buffer */
start = self->firstChain;
while( (chain = self->firstChain) && chain!=start) {
logdebug("Destroying BufferChain at %p\n", chain);
self->firstChain = chain->next;
mbuf_destroy(chain->mbuf);
xfree(chain);
}
return 0;
}
