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( hb_fifo_t * f )
 239 {
 240     int ret;
 241
 242     hb_lock( f->lock );
 243     ret = f->size;
 244     hb_unlock( f->lock );
 245
 246     return ret;
 247 }
 248
 249 int hb_fifo_is_full( hb_fifo_t * f )
 250 {
 251     int ret;
 252
 253     hb_lock( f->lock );
 254     ret = ( f->size >= f->capacity );
 255     hb_unlock( f->lock );
 256
 257     return ret;
 258 }
 259
 260 float hb_fifo_percent_full( hb_fifo_t * f )
 261 {
 262     float ret;
 263
 264     hb_lock( f->lock );
 265     ret = f->size / f->capacity;
 266     hb_unlock( f->lock );
 267
 268     return ret;
 269 }
 270
 271 hb_buffer_t * hb_fifo_get_wait( hb_fifo_t * f )
 272 {
 273     hb_buffer_t * b;
 274
 275     hb_lock( f->lock );
 276     if( f->size < 1 )
 277     {
 278         f->wait_empty = 1;
 279         hb_cond_timedwait( f->cond_empty, f->lock, FIFO_TIMEOUT );
 280         if( f->size < 1 )
 281         {
 282             hb_unlock( f->lock );
 283             return NULL;
 284         }
 285     }
 286     b         = f->first;
 287     f->first  = b->next;
 288     b->next   = NULL;
 289     f->size  -= 1;
 290     if( f->wait_full && f->size == f->capacity - f->thresh )
 291     {
 292         f->wait_full = 0;
 293         hb_cond_signal( f->cond_full );
 294     }
 295     hb_unlock( f->lock );
 296
 297     return b;
 298 }
 299
 300 hb_buffer_t * hb_fifo_get( hb_fifo_t * f )
 301 {
 302     hb_buffer_t * b;
 303
 304     hb_lock( f->lock );
 305     if( f->size < 1 )
 306     {
 307         hb_unlock( f->lock );
 308         return NULL;
 309     }
 310     b         = f->first;
 311     f->first  = b->next;
 312     b->next   = NULL;
 313     f->size  -= 1;
 314     if( f->wait_full && f->size == f->capacity - f->thresh )
 315     {
 316         f->wait_full = 0;
 317         hb_cond_signal( f->cond_full );
 318     }
 319     hb_unlock( f->lock );
 320
 321     return b;
 322 }
 323
 324 hb_buffer_t * hb_fifo_see_wait( hb_fifo_t * f )
 325 {
 326     hb_buffer_t * b;
 327
 328     hb_lock( f->lock );
 329     if( f->size < 1 )
 330     {
 331         f->wait_empty = 1;
 332         hb_cond_timedwait( f->cond_empty, f->lock, FIFO_TIMEOUT );
 333         if( f->size < 1 )
 334         {
 335             hb_unlock( f->lock );
 336             return NULL;
 337         }
 338     }
 339     b = f->first;
 340     hb_unlock( f->lock );
 341
 342     return b;
 343 }
 344
 345 hb_buffer_t * hb_fifo_see( hb_fifo_t * f )
 346 {
 347     hb_buffer_t * b;
 348
 349     hb_lock( f->lock );
 350     if( f->size < 1 )
 351     {
 352         hb_unlock( f->lock );
 353         return NULL;
 354     }
 355     b = f->first;
 356     hb_unlock( f->lock );
 357
 358     return b;
 359 }
 360
 361 hb_buffer_t * hb_fifo_see2( hb_fifo_t * f )
 362 {
 363     hb_buffer_t * b;
 364
 365     hb_lock( f->lock );
 366     if( f->size < 2 )
 367     {
 368         hb_unlock( f->lock );
 369         return NULL;
 370     }
 371     b = f->first->next;
 372     hb_unlock( f->lock );
 373
 374     return b;
 375 }
 376
 377 void hb_fifo_push_wait( hb_fifo_t * f, hb_buffer_t * b )
 378 {
 379     if( !b )
 380     {
 381         return;
 382     }
 383
 384     hb_lock( f->lock );
 385     if( f->size >= f->capacity )
 386     {
 387         f->wait_full = 1;
 388         hb_cond_timedwait( f->cond_full, f->lock, FIFO_TIMEOUT );
 389     }
 390     if( f->size > 0 )
 391     {
 392         f->last->next = b;
 393     }
 394     else
 395     {
 396         f->first = b;
 397     }
 398     f->last  = b;
 399     f->size += 1;
 400     while( f->last->next )
 401     {
 402         f->size += 1;
 403         f->last  = f->last->next;
 404     }
 405     if( f->wait_empty && f->size >= f->thresh )
 406     {
 407         f->wait_empty = 0;
 408         hb_cond_signal( f->cond_empty );
 409     }
 410     hb_unlock( f->lock );
 411 }
 412
 413 void hb_fifo_push( hb_fifo_t * f, hb_buffer_t * b )
 414 {
 415     if( !b )
 416     {
 417         return;
 418     }
 419
 420     hb_lock( f->lock );
 421     if( f->size > 0 )
 422     {
 423         f->last->next = b;
 424     }
 425     else
 426     {
 427         f->first = b;
 428     }
 429     f->last  = b;
 430     f->size += 1;
 431     while( f->last->next )
 432     {
 433         f->size += 1;
 434         f->last  = f->last->next;
 435     }
 436     if( f->wait_empty && f->size >= f->thresh )
 437     {
 438         f->wait_empty = 0;
 439         hb_cond_signal( f->cond_empty );
 440     }
 441     hb_unlock( f->lock );
 442 }
 443
 444 void hb_fifo_push_head( hb_fifo_t * f, hb_buffer_t * b )
 445 {
 446     hb_buffer_t * tmp;
 447     uint32_t      size = 0;
 448
 449     if( !b )
 450     {
 451         return;
 452     }
 453
 454     hb_lock( f->lock );
 455
 456     /*
 457      * If there are a chain of buffers prepend the lot
 458      */
 459     tmp = b;
 460     while( tmp->next )
 461     {
 462         tmp = tmp->next;
 463         size += 1;
 464     }
 465
 466     if( f->size > 0 )
 467     {
 468         tmp->next = f->first;
 469     }
 470     else
 471     {
 472         f->last = tmp;
 473     }
 474
 475     f->first = b;
 476     f->size += ( size + 1 );
 477
 478     hb_unlock( f->lock );
 479 }
 480
 481 void hb_fifo_close( hb_fifo_t ** _f )
 482 {
 483     hb_fifo_t   * f = *_f;
 484     hb_buffer_t * b;
 485
 486     hb_deep_log( 2, "fifo_close: trashing %d buffer(s)", hb_fifo_size( f ) );
 487     while( ( b = hb_fifo_get( f ) ) )
 488     {
 489         hb_buffer_close( &b );
 490     }
 491
 492     hb_lock_close( &f->lock );
 493     hb_cond_close( &f->cond_empty );
 494     hb_cond_close( &f->cond_full );
 495     free( f );
 496
 497     *_f = NULL;
 498 }
 499
 500 void hb_fifo_flush( hb_fifo_t * f )
 501 {
 502     hb_buffer_t * b;
 503
 504     while( ( b = hb_fifo_get( f ) ) )
 505     {
 506         hb_buffer_close( &b );
 507     }
 508     hb_lock( f->lock );
 509     hb_cond_signal( f->cond_empty );
 510     hb_cond_signal( f->cond_full );
 511     hb_unlock( f->lock );
 512
 513 }
 514