libhb/fifo.c

   1 /* $Id: fifo.c,v 1.17 2005/10/15 18:05:03 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8
   9 #ifndef SYS_DARWIN
  10 #include <malloc.h>
  11 #endif
  12
  13 #define FIFO_TIMEOUT 200
  14
  15 /* Fifo */
  16 struct hb_fifo_s
  17 {
  18     hb_lock_t    * lock;
  19     hb_cond_t    * cond_full;
  20     int            wait_full;
  21     hb_cond_t    * cond_empty;
  22     int            wait_empty;
  23     uint32_t       capacity;
  24     uint32_t       thresh;
  25     uint32_t       size;
  26     uint32_t       buffer_size;
  27     hb_buffer_t  * first;
  28     hb_buffer_t  * last;
  29 };
  30
  31 /* we round the requested buffer size up to the next power of 2 so there can
  32  * be at most 32 possible pools when the size is a 32 bit int. To avoid a lot
  33  * of slow & error-prone run-time checking we allow for all 32. */
  34 #define MAX_BUFFER_POOLS  32
  35 /* the buffer pool only exists to avoid the two malloc and two free calls that
  36  * it would otherwise take to allocate & free a buffer. but we don't want to
  37  * tie up a lot of memory in the pool because this allocator isn't as general
  38  * as malloc so memory tied up here puts more pressure on the malloc pool.
  39  * A pool of 16 elements will avoid 94% of the malloc/free calls without wasting
  40  * too much memory. */
  41 #define BUFFER_POOL_MAX_ELEMENTS 32
  42
  43 struct hb_buffer_pools_s
  44 {
  45     int64_t allocated;
  46     hb_lock_t *lock;
  47     hb_fifo_t *pool[MAX_BUFFER_POOLS];
  48 } buffers;
  49
  50
  51 void hb_buffer_pool_init( void )
  52 {
  53     buffers.lock = hb_lock_init();
  54     buffers.allocated = 0;
  55
  56     /* we allocate pools for sizes 2^10 through 2^25. requests larger than
  57      * 2^25 will get passed through to malloc. */
  58     int i;
  59     for ( i = 10; i < 26; ++i )
  60     {
  61         buffers.pool[i] = hb_fifo_init(BUFFER_POOL_MAX_ELEMENTS, 1);
  62         buffers.pool[i]->buffer_size = 1 << i;
  63     }
  64     /* requests smaller than 2^10 are satisfied from the 2^10 pool. */
  65     for ( i = 1; i < 10; ++i )
  66     {
  67         buffers.pool[i] = buffers.pool[10];
  68     }
  69 }
  70
  71 void hb_buffer_pool_free( void )
  72 {
  73     int i;
  74     int count;
  75     int64_t freed = 0;
  76     hb_buffer_t *b;
  77
  78     hb_lock(buffers.lock);
  79
  80     for( i = 10; i < 26; ++i)
  81     {
  82         count = 0;
  83         while( ( b = hb_fifo_get(buffers.pool[i]) ) )
  84         {
  85             freed += b->alloc;
  86             if( b->data )
  87             {
  88                 free( b->data );
  89             }
  90             free( b );
  91             count++;
  92         }
  93         if ( count )
  94         {
  95             hb_deep_log( 2, "Freed %d buffers of size %d", count,
  96                     buffers.pool[i]->buffer_size);
  97         }
  98     }
  99
 100     hb_deep_log( 2, "Allocated %"PRId64" bytes of buffers on this pass and Freed %"PRId64" bytes, "
 101            "%"PRId64" bytes leaked", buffers.allocated, freed, buffers.allocated - freed);
 102     buffers.allocated = 0;
 103     hb_unlock(buffers.lock);
 104 }
 105
 106 static hb_fifo_t *size_to_pool( int size )
 107 {
 108     int i;
 109     for ( i = 0; i < 30; ++i )
 110     {
 111         if ( size <= (1 << i) )
 112         {
 113             return buffers.pool[i];
 114         }
 115     }
 116     return NULL;
 117 }
 118
 119 hb_buffer_t * hb_buffer_init( int size )
 120 {
 121     hb_buffer_t * b;
 122     hb_fifo_t *buffer_pool = size_to_pool( size );
 123
 124     if( buffer_pool )
 125     {
 126         b = hb_fifo_get( buffer_pool );
 127
 128         if( b )
 129         {
 130             /*
 131              * Zero the contents of the buffer, would be nice if we
 132              * didn't have to do this.
 133              */
 134             uint8_t *data = b->data;
 135             memset( b, 0, sizeof(hb_buffer_t) );
 136             b->alloc = buffer_pool->buffer_size;
 137             b->size = size;
 138             b->data = data;
 139             return( b );
 140         }
 141     }
 142
 143     /*
 144      * No existing buffers, create a new one
 145      */
 146     if( !( b = calloc( sizeof( hb_buffer_t ), 1 ) ) )
 147     {
 148         hb_log( "out of memory" );
 149         return NULL;
 150     }
 151
 152     b->size  = size;
 153     b->alloc  = buffer_pool? buffer_pool->buffer_size : size;
 154
 155     if (size)
 156     {
 157 #if defined( SYS_DARWIN ) || defined( SYS_FREEBSD ) || defined( SYS_MINGW )
 158         b->data  = malloc( b->alloc );
 159 #elif defined( SYS_CYGWIN )
 160         /* FIXME */
 161         b->data  = malloc( b->alloc + 17 );
 162 #else
 163         b->data  = memalign( 16, b->alloc );
 164 #endif
 165         if( !b->data )
 166         {
 167             hb_log( "out of memory" );
 168             free( b );
 169             return NULL;
 170         }
 171         hb_lock(buffers.lock);
 172         buffers.allocated += b->alloc;
 173         hb_unlock(buffers.lock);
 174     }
 175     return b;
 176 }
 177
 178 void hb_buffer_realloc( hb_buffer_t * b, int size )
 179 {
 180     if ( size > b->alloc )
 181     {
 182         uint32_t orig = b->alloc;
 183         size = size_to_pool( size )->buffer_size;
 184         b->data  = realloc( b->data, size );
 185         b->alloc = size;
 186
 187         hb_lock(buffers.lock);
 188         buffers.allocated += size - orig;
 189         hb_unlock(buffers.lock);
 190     }
 191 }
 192
 193 void hb_buffer_close( hb_buffer_t ** _b )
 194 {
 195     hb_buffer_t * b = *_b;
 196     hb_fifo_t *buffer_pool = size_to_pool( b->alloc );
 197
 198     if( buffer_pool && b->data && !hb_fifo_is_full( buffer_pool ) )
 199     {
 200         hb_fifo_push_head( buffer_pool, b );
 201         *_b = NULL;
 202         return;
 203     }
 204     /* either the pool is full or this size doesn't use a pool - free the buf */
 205     if( b->data )
 206     {
 207         free( b->data );
 208         hb_lock(buffers.lock);
 209         buffers.allocated -= b->alloc;
 210         hb_unlock(buffers.lock);
 211     }
 212     free( b );
 213     *_b = NULL;
 214 }
 215
 216 void hb_buffer_copy_settings( hb_buffer_t * dst, const hb_buffer_t * src )
 217 {
 218     dst->start     = src->start;
 219     dst->stop      = src->stop;
 220     dst->new_chap  = src->new_chap;
 221     dst->frametype = src->frametype;
 222     dst->flags     = src->flags;
 223 }
 224
 225 hb_fifo_t * hb_fifo_init( int capacity, int thresh )
 226 {
 227     hb_fifo_t * f;
 228     f             = calloc( sizeof( hb_fifo_t ), 1 );
 229     f->lock       = hb_lock_init();
 230     f->cond_full  = hb_cond_init();
 231     f->cond_empty = hb_cond_init();
 232     f->capacity   = capacity;
 233     f->thresh     = thresh;
 234     f->buffer_size = 0;
 235     return f;
 236 }
 237
 238 int hb_fifo_size_bytes( hb_fifo_t * f )
 239 {
 240     int ret = 0;
 241     hb_buffer_t * link;
 242
 243     hb_lock( f->lock );
 244     link = f->first;
 245     while ( link )
 246     {
 247         ret += link->size;
 248         link = link->next;
 249     }
 250     hb_unlock( f->lock );
 251
 252     return ret;
 253 }
 254
 255 int hb_fifo_size( hb_fifo_t * f )
 256 {
 257     int ret;
 258
 259     hb_lock( f->lock );
 260     ret = f->size;
 261     hb_unlock( f->lock );
 262
 263     return ret;
 264 }
 265
 266 int hb_fifo_is_full( hb_fifo_t * f )
 267 {
 268     int ret;
 269
 270     hb_lock( f->lock );
 271     ret = ( f->size >= f->capacity );
 272     hb_unlock( f->lock );
 273
 274     return ret;
 275 }
 276
 277 float hb_fifo_percent_full( hb_fifo_t * f )
 278 {
 279     float ret;
 280
 281     hb_lock( f->lock );
 282     ret = f->size / f->capacity;
 283     hb_unlock( f->lock );
 284
 285     return ret;
 286 }
 287
 288 hb_buffer_t * hb_fifo_get_wait( hb_fifo_t * f )
 289 {
 290     hb_buffer_t * b;
 291
 292     hb_lock( f->lock );
 293     if( f->size < 1 )
 294     {
 295         f->wait_empty = 1;
 296         hb_cond_timedwait( f->cond_empty, f->lock, FIFO_TIMEOUT );
 297         if( f->size < 1 )
 298         {
 299             hb_unlock( f->lock );
 300             return NULL;
 301         }
 302     }
 303     b         = f->first;
 304     f->first  = b->next;
 305     b->next   = NULL;
 306     f->size  -= 1;
 307     if( f->wait_full && f->size == f->capacity - f->thresh )
 308     {
 309         f->wait_full = 0;
 310         hb_cond_signal( f->cond_full );
 311     }
 312     hb_unlock( f->lock );
 313
 314     return b;
 315 }
 316
 317 hb_buffer_t * hb_fifo_get( hb_fifo_t * f )
 318 {
 319     hb_buffer_t * b;
 320
 321     hb_lock( f->lock );
 322     if( f->size < 1 )
 323     {
 324         hb_unlock( f->lock );
 325         return NULL;
 326     }
 327     b         = f->first;
 328     f->first  = b->next;
 329     b->next   = NULL;
 330     f->size  -= 1;
 331     if( f->wait_full && f->size == f->capacity - f->thresh )
 332     {
 333         f->wait_full = 0;
 334         hb_cond_signal( f->cond_full );
 335     }
 336     hb_unlock( f->lock );
 337
 338     return b;
 339 }
 340
 341 hb_buffer_t * hb_fifo_see_wait( hb_fifo_t * f )
 342 {
 343     hb_buffer_t * b;
 344
 345     hb_lock( f->lock );
 346     if( f->size < 1 )
 347     {
 348         f->wait_empty = 1;
 349         hb_cond_timedwait( f->cond_empty, f->lock, FIFO_TIMEOUT );
 350         if( f->size < 1 )
 351         {
 352             hb_unlock( f->lock );
 353             return NULL;
 354         }
 355     }
 356     b = f->first;
 357     hb_unlock( f->lock );
 358
 359     return b;
 360 }
 361
 362 hb_buffer_t * hb_fifo_see( hb_fifo_t * f )
 363 {
 364     hb_buffer_t * b;
 365
 366     hb_lock( f->lock );
 367     if( f->size < 1 )
 368     {
 369         hb_unlock( f->lock );
 370         return NULL;
 371     }
 372     b = f->first;
 373     hb_unlock( f->lock );
 374
 375     return b;
 376 }
 377
 378 hb_buffer_t * hb_fifo_see2( hb_fifo_t * f )
 379 {
 380     hb_buffer_t * b;
 381
 382     hb_lock( f->lock );
 383     if( f->size < 2 )
 384     {
 385         hb_unlock( f->lock );
 386         return NULL;
 387     }
 388     b = f->first->next;
 389     hb_unlock( f->lock );
 390
 391     return b;
 392 }
 393
 394 int hb_fifo_full_wait( hb_fifo_t * f )
 395 {
 396     int result;
 397
 398     hb_lock( f->lock );
 399     if( f->size >= f->capacity )
 400     {
 401         f->wait_full = 1;
 402         hb_cond_timedwait( f->cond_full, f->lock, FIFO_TIMEOUT );
 403     }
 404     result = ( f->size < f->capacity );
 405     hb_unlock( f->lock );
 406     return result;
 407 }
 408
 409 void hb_fifo_push_wait( hb_fifo_t * f, hb_buffer_t * b )
 410 {
 411     if( !b )
 412     {
 413         return;
 414     }
 415
 416     hb_lock( f->lock );
 417     if( f->size >= f->capacity )
 418     {
 419         f->wait_full = 1;
 420         hb_cond_timedwait( f->cond_full, f->lock, FIFO_TIMEOUT );
 421     }
 422     if( f->size > 0 )
 423     {
 424         f->last->next = b;
 425     }
 426     else
 427     {
 428         f->first = b;
 429     }
 430     f->last  = b;
 431     f->size += 1;
 432     while( f->last->next )
 433     {
 434         f->size += 1;
 435         f->last  = f->last->next;
 436     }
 437     if( f->wait_empty && f->size >= f->thresh )
 438     {
 439         f->wait_empty = 0;
 440         hb_cond_signal( f->cond_empty );
 441     }
 442     hb_unlock( f->lock );
 443 }
 444
 445 void hb_fifo_push( hb_fifo_t * f, hb_buffer_t * b )
 446 {
 447     if( !b )
 448     {
 449         return;
 450     }
 451
 452     hb_lock( f->lock );
 453     if( f->size > 0 )
 454     {
 455         f->last->next = b;
 456     }
 457     else
 458     {
 459         f->first = b;
 460     }
 461     f->last  = b;
 462     f->size += 1;
 463     while( f->last->next )
 464     {
 465         f->size += 1;
 466         f->last  = f->last->next;
 467     }
 468     if( f->wait_empty && f->size >= f->thresh )
 469     {
 470         f->wait_empty = 0;
 471         hb_cond_signal( f->cond_empty );
 472     }
 473     hb_unlock( f->lock );
 474 }
 475
 476 void hb_fifo_push_head( hb_fifo_t * f, hb_buffer_t * b )
 477 {
 478     hb_buffer_t * tmp;
 479     uint32_t      size = 0;
 480
 481     if( !b )
 482     {
 483         return;
 484     }
 485
 486     hb_lock( f->lock );
 487
 488     /*
 489      * If there are a chain of buffers prepend the lot
 490      */
 491     tmp = b;
 492     while( tmp->next )
 493     {
 494         tmp = tmp->next;
 495         size += 1;
 496     }
 497
 498     if( f->size > 0 )
 499     {
 500         tmp->next = f->first;
 501     }
 502     else
 503     {
 504         f->last = tmp;
 505     }
 506
 507     f->first = b;
 508     f->size += ( size + 1 );
 509
 510     hb_unlock( f->lock );
 511 }
 512
 513 void hb_fifo_close( hb_fifo_t ** _f )
 514 {
 515     hb_fifo_t   * f = *_f;
 516     hb_buffer_t * b;
 517
 518     hb_deep_log( 2, "fifo_close: trashing %d buffer(s)", hb_fifo_size( f ) );
 519     while( ( b = hb_fifo_get( f ) ) )
 520     {
 521         hb_buffer_close( &b );
 522     }
 523
 524     hb_lock_close( &f->lock );
 525     hb_cond_close( &f->cond_empty );
 526     hb_cond_close( &f->cond_full );
 527     free( f );
 528
 529     *_f = NULL;
 530 }
 531
 532 void hb_fifo_flush( hb_fifo_t * f )
 533 {
 534     hb_buffer_t * b;
 535
 536     while( ( b = hb_fifo_get( f ) ) )
 537     {
 538         hb_buffer_close( &b );
 539     }
 540     hb_lock( f->lock );
 541     hb_cond_signal( f->cond_empty );
 542     hb_cond_signal( f->cond_full );
 543     hb_unlock( f->lock );
 544
 545 }
 546