ftccache.c File Reference

#include <ft2build.h>
#include "ftcmanag.h"
#include "ftccback.h"
#include "ftcerror.h"

Include dependency graph for ftccache.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FT_COMPONENT   trace_cache
#define	FTC_HASH_MAX_LOAD   2
#define	FTC_HASH_MIN_LOAD   1
#define	FTC_HASH_SUB_LOAD   ( FTC_HASH_MAX_LOAD - FTC_HASH_MIN_LOAD )
#define	FTC_HASH_INITIAL_SIZE   8

Functions
static void	ftc_node_mru_link (FTC_Node node, FTC_Manager manager)
static void	ftc_node_mru_unlink (FTC_Node node, FTC_Manager manager)
static void	ftc_cache_resize (FTC_Cache cache)
static void	ftc_node_hash_unlink (FTC_Node node0, FTC_Cache cache)
static void	ftc_node_hash_link (FTC_Node node, FTC_Cache cache)
	ftc_node_destroy (FTC_Node node, FTC_Manager manager)
	FTC_Cache_Init (FTC_Cache cache)
	ftc_cache_init (FTC_Cache cache)
static void	FTC_Cache_Clear (FTC_Cache cache)
	ftc_cache_done (FTC_Cache cache)
	FTC_Cache_Done (FTC_Cache cache)
static void	ftc_cache_add (FTC_Cache cache, FT_Offset hash, FTC_Node node)
	FTC_Cache_NewNode (FTC_Cache cache, FT_Offset hash, FT_Pointer query, FTC_Node *anode)
	FTC_Cache_RemoveFaceID (FTC_Cache cache, FTC_FaceID face_id)

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_cache

Definition at line 28 of file ftccache.c.

FTC_HASH_INITIAL_SIZE

#define FTC_HASH_INITIAL_SIZE   8

Definition at line 36 of file ftccache.c.

FTC_HASH_MAX_LOAD

#define FTC_HASH_MAX_LOAD   2

Definition at line 31 of file ftccache.c.

FTC_HASH_MIN_LOAD

#define FTC_HASH_MIN_LOAD   1

Definition at line 32 of file ftccache.c.

FTC_HASH_SUB_LOAD

#define FTC_HASH_SUB_LOAD   ( FTC_HASH_MAX_LOAD - FTC_HASH_MIN_LOAD )

Definition at line 33 of file ftccache.c.

Function Documentation

ftc_cache_add()

static void ftc_cache_add ( FTC_Cache  cache, FT_Offset  hash, FTC_Node  node  )

static

Definition at line 416 of file ftccache.c.

  {
    node->hash        = hash;
    node->cache_index = (FT_UInt16)cache->index;
    node->ref_count   = 0;
 
    ftc_node_hash_link( node, cache );
    ftc_node_mru_link( node, cache->manager );
 
    {
      FTC_Manager  manager = cache->manager;
 
 
      manager->cur_weight += cache->clazz.node_weight( node, cache );
 
      if ( manager->cur_weight >= manager->max_weight )
      {
        node->ref_count++;
        FTC_Manager_Compress( manager );
        node->ref_count--;
      }
    }
  }

Referenced by FTC_Cache_NewNode().

FTC_Cache_Clear()

static void FTC_Cache_Clear ( FTC_Cache  cache )

static

Definition at line 351 of file ftccache.c.

  {
    if ( cache && cache->buckets )
    {
      FTC_Manager  manager = cache->manager;
      FT_UFast     i;
      FT_UFast     count;
 
 
      count = cache->p + cache->mask + 1;
 
      for ( i = 0; i < count; i++ )
      {
        FTC_Node  *pnode = cache->buckets + i, next, node = *pnode;
 
 
        while ( node )
        {
          next        = node->link;
          node->link  = NULL;
 
          /* remove node from mru list */
          ftc_node_mru_unlink( node, manager );
 
          /* now finalize it */
          manager->cur_weight -= cache->clazz.node_weight( node, cache );
 
          cache->clazz.node_free( node, cache );
          node = next;
        }
        cache->buckets[i] = NULL;
      }
      ftc_cache_resize( cache );
    }
  }

Referenced by ftc_cache_done().

ftc_cache_done()

ftc_cache_done

(

FTC_Cache

cache

)

Definition at line 389 of file ftccache.c.

  {
    if ( cache->memory )
    {
      FT_Memory  memory = cache->memory;
 
 
      FTC_Cache_Clear( cache );
 
      FT_FREE( cache->buckets );
      cache->mask  = 0;
      cache->p     = 0;
      cache->slack = 0;
 
      cache->memory = NULL;
    }
  }

Referenced by FTC_Cache_Done().

FTC_Cache_Done()

FTC_Cache_Done

(

FTC_Cache

cache

)

Definition at line 409 of file ftccache.c.

  {
    ftc_cache_done( cache );
  }

Referenced by ftc_gcache_done().

FTC_Cache_Init()

FTC_Cache_Init

(

FTC_Cache

cache

)

Definition at line 328 of file ftccache.c.

  {
    return ftc_cache_init( cache );
  }

Referenced by ftc_gcache_init().

ftc_cache_init()

ftc_cache_init

(

FTC_Cache

cache

)

Definition at line 335 of file ftccache.c.

  {
    FT_Memory  memory = cache->memory;
    FT_Error   error;
 
 
    cache->p     = 0;
    cache->mask  = FTC_HASH_INITIAL_SIZE - 1;
    cache->slack = FTC_HASH_INITIAL_SIZE * FTC_HASH_MAX_LOAD;
 
    (void)FT_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE * 2 );
    return error;
  }

Referenced by FTC_Cache_Init().

FTC_Cache_NewNode()

FTC_Cache_NewNode	(	FTC_Cache	cache,
		FT_Offset	hash,
		FT_Pointer	query,
		FTC_Node *	anode
	)

Definition at line 444 of file ftccache.c.

  {
    FT_Error  error;
    FTC_Node  node;
 
 
    /*
     * We use the FTC_CACHE_TRYLOOP macros to support out-of-memory
     * errors (OOM) correctly, i.e., by flushing the cache progressively
     * in order to make more room.
     */
 
    FTC_CACHE_TRYLOOP( cache )
    {
      error = cache->clazz.node_new( &node, query, cache );
    }
    FTC_CACHE_TRYLOOP_END( NULL );
 
    if ( error )
      node = NULL;
    else
    {
     /* don't assume that the cache has the same number of buckets, since
      * our allocation request might have triggered global cache flushing
      */
      ftc_cache_add( cache, hash, node );
    }
 
    *anode = node;
    return error;
  }

FTC_Cache_RemoveFaceID()

FTC_Cache_RemoveFaceID	(	FTC_Cache	cache,
		FTC_FaceID	face_id
	)

Definition at line 564 of file ftccache.c.

  {
    FT_UFast     i, count;
    FTC_Manager  manager = cache->manager;
    FTC_Node     frees   = NULL;
 
 
    count = cache->p + cache->mask + 1;
    for ( i = 0; i < count; i++ )
    {
      FTC_Node*  bucket = cache->buckets + i;
      FTC_Node*  pnode  = bucket;
 
 
      for (;;)
      {
        FTC_Node  node = *pnode;
        FT_Bool   list_changed = FALSE;
 
 
        if ( !node )
          break;
 
        if ( cache->clazz.node_remove_faceid( node, face_id,
                                              cache, &list_changed ) )
        {
          *pnode     = node->link;
          node->link = frees;
          frees      = node;
        }
        else
          pnode = &node->link;
      }
    }
 
    /* remove all nodes in the free list */
    while ( frees )
    {
      FTC_Node  node;
 
 
      node  = frees;
      frees = node->link;
 
      manager->cur_weight -= cache->clazz.node_weight( node, cache );
      ftc_node_mru_unlink( node, manager );
 
      cache->clazz.node_free( node, cache );
 
      cache->slack++;
    }
 
    ftc_cache_resize( cache );
  }

Referenced by FTC_Manager_RemoveFaceID().

ftc_cache_resize()

static void ftc_cache_resize ( FTC_Cache  cache )

static

Definition at line 113 of file ftccache.c.

  {
    for (;;)
    {
      FTC_Node  node, *pnode;
      FT_UFast  p     = cache->p;
      FT_UFast  mask  = cache->mask;
      FT_UFast  count = mask + p + 1;    /* number of buckets */
 
 
      /* do we need to shrink the buckets array? */
      if ( cache->slack < 0 )
      {
        FTC_Node  new_list = NULL;
 
 
        /* try to expand the buckets array _before_ splitting
         * the bucket lists
         */
        if ( p >= mask )
        {
          FT_Memory  memory = cache->memory;
          FT_Error   error;
 
 
          /* if we can't expand the array, leave immediately */
          if ( FT_RENEW_ARRAY( cache->buckets,
                               ( mask + 1 ) * 2, ( mask + 1 ) * 4 ) )
            break;
        }
 
        /* split a single bucket */
        pnode = cache->buckets + p;
 
        for (;;)
        {
          node = *pnode;
          if ( !node )
            break;
 
          if ( node->hash & ( mask + 1 ) )
          {
            *pnode     = node->link;
            node->link = new_list;
            new_list   = node;
          }
          else
            pnode = &node->link;
        }
 
        cache->buckets[p + mask + 1] = new_list;
 
        cache->slack += FTC_HASH_MAX_LOAD;
 
        if ( p >= mask )
        {
          cache->mask = 2 * mask + 1;
          cache->p    = 0;
        }
        else
          cache->p = p + 1;
      }
 
      /* do we need to expand the buckets array? */
      else if ( cache->slack > (FT_Long)count * FTC_HASH_SUB_LOAD )
      {
        FT_UFast   old_index = p + mask;
        FTC_Node*  pold;
 
 
        if ( old_index + 1 <= FTC_HASH_INITIAL_SIZE )
          break;
 
        if ( p == 0 )
        {
          FT_Memory  memory = cache->memory;
          FT_Error   error;
 
 
          /* if we can't shrink the array, leave immediately */
          if ( FT_RENEW_ARRAY( cache->buckets,
                               ( mask + 1 ) * 2, mask + 1 ) )
            break;
 
          cache->mask >>= 1;
          p             = cache->mask;
        }
        else
          p--;
 
        pnode = cache->buckets + p;
        while ( *pnode )
          pnode = &(*pnode)->link;
 
        pold   = cache->buckets + old_index;
        *pnode = *pold;
        *pold  = NULL;
 
        cache->slack -= FTC_HASH_MAX_LOAD;
        cache->p      = p;
      }
 
      /* otherwise, the hash table is balanced */
      else
        break;
    }
  }

Referenced by FTC_Cache_Clear(), FTC_Cache_RemoveFaceID(), ftc_node_hash_link(), and ftc_node_hash_unlink().

ftc_node_destroy()

ftc_node_destroy	(	FTC_Node	node,
		FTC_Manager	manager
	)

Definition at line 273 of file ftccache.c.

  {
    FTC_Cache  cache;
 
 
#ifdef FT_DEBUG_ERROR
    /* find node's cache */
    if ( node->cache_index >= manager->num_caches )
    {
      FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
      return;
    }
#endif
 
    cache = manager->caches[node->cache_index];
 
#ifdef FT_DEBUG_ERROR
    if ( !cache )
    {
      FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
      return;
    }
#endif
 
    manager->cur_weight -= cache->clazz.node_weight( node, cache );
 
    /* remove node from mru list */
    ftc_node_mru_unlink( node, manager );
 
    /* remove node from cache's hash table */
    ftc_node_hash_unlink( node, cache );
 
    /* now finalize it */
    cache->clazz.node_free( node, cache );
 
#if 0
    /* check, just in case of general corruption :-) */
    if ( manager->num_nodes == 0 )
      FT_TRACE0(( "ftc_node_destroy: invalid cache node count (%d)\n",
                  manager->num_nodes ));
#endif
  }

Referenced by FTC_Manager_Compress(), and FTC_Manager_FlushN().

ftc_node_hash_link()

static void ftc_node_hash_link ( FTC_Node  node, FTC_Cache  cache  )

static

Definition at line 257 of file ftccache.c.

  {
    FTC_Node  *pnode = FTC_NODE_TOP_FOR_HASH( cache, node->hash );
 
 
    node->link = *pnode;
    *pnode     = node;
 
    cache->slack--;
    ftc_cache_resize( cache );
  }

Referenced by ftc_cache_add().

ftc_node_hash_unlink()

static void ftc_node_hash_unlink ( FTC_Node  node0, FTC_Cache  cache  )

static

Definition at line 224 of file ftccache.c.

  {
    FTC_Node  *pnode = FTC_NODE_TOP_FOR_HASH( cache, node0->hash );
 
 
    for (;;)
    {
      FTC_Node  node = *pnode;
 
 
      if ( !node )
      {
        FT_TRACE0(( "ftc_node_hash_unlink: unknown node\n" ));
        return;
      }
 
      if ( node == node0 )
        break;
 
      pnode = &(*pnode)->link;
    }
 
    *pnode      = node0->link;
    node0->link = NULL;
 
    cache->slack++;
    ftc_cache_resize( cache );
  }

Referenced by ftc_node_destroy().

ftc_node_mru_link()

static void ftc_node_mru_link ( FTC_Node  node, FTC_Manager  manager  )

static

Definition at line 49 of file ftccache.c.

  {
    void  *nl = &manager->nodes_list;
 
 
    FTC_MruNode_Prepend( (FTC_MruNode*)nl,
                         (FTC_MruNode)node );
    manager->num_nodes++;
  }

Referenced by ftc_cache_add().

ftc_node_mru_unlink()

static void ftc_node_mru_unlink ( FTC_Node  node, FTC_Manager  manager  )

static

Definition at line 63 of file ftccache.c.

  {
    void  *nl = &manager->nodes_list;
 
 
    FTC_MruNode_Remove( (FTC_MruNode*)nl,
                        (FTC_MruNode)node );
    manager->num_nodes--;
  }

Referenced by FTC_Cache_Clear(), FTC_Cache_RemoveFaceID(), and ftc_node_destroy().