/*

 * Copyright 2008-2009 Katholieke Universiteit Leuven

 *

 * Use of this software is governed by the MIT license

 *

 * Written by Sven Verdoolaege, K.U.Leuven, Departement

 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium

 */

#include <isl_blk.h>

#include <isl_ctx_private.h>

/* The maximal number of cache misses before first element is evicted */

#define ISL_BLK_MAX_MISS  100

struct isl_blk isl_blk_empty()

{

  struct isl_blk block;

  block.size = 0;

  block.data = NULL;

  return block;

}

static int isl_blk_is_empty(struct isl_blk block)

{

  return block.size == 0 && 
block.data == NULL11.0M
;

}

static struct isl_blk isl_blk_error()

{

  struct isl_blk block;

  block.size = -1;

  block.data = NULL;

  return block;

}

int isl_blk_is_error(struct isl_blk block)

{

  return block.size == -1 && 
block.data == NULL0
;

}

static void isl_blk_free_force(struct isl_ctx *ctx, struct isl_blk block)

{

  int i;

  for (i = 0; i < block.size; 
++i118M
)

    isl_int_clear(block.data[i]);

  free(block.data);

}

static struct isl_blk extend(struct isl_ctx *ctx, struct isl_blk block,

        size_t new_n)

{

  int i;

  isl_int *p;

  if (block.size >= new_n)

    return block;

  p = isl_realloc_array(ctx, block.data, isl_int, new_n);

  if (!p) {

    isl_blk_free_force(ctx, block);

    return isl_blk_error();

  }

  block.data = p;

  for (i = block.size; i < new_n; 
++i118M
)

    isl_int_init(block.data[i]);

  block.size = new_n;

  return block;

}

struct isl_blk isl_blk_alloc(struct isl_ctx *ctx, size_t n)

{

  int i;

  struct isl_blk block;

  block = isl_blk_empty();

  if (n && 
ctx->n_cached18.1M
) {

    int best = 0;

    for (i = 1; ctx->cache[best].size != n && 
i < ctx->n_cached179M
; 
++i165M
) {

      if (ctx->cache[best].size < n) {

        if (ctx->cache[i].size > ctx->cache[best].size)

          best = i;

      } else if (ctx->cache[i].size >= n &&

           
ctx->cache[i].size < ctx->cache[best].size85.5M
)

          best = i;

    }

    if (ctx->cache[best].size < 2 * n + 100) {

      block = ctx->cache[best];

      if (--ctx->n_cached != best)

        ctx->cache[best] = ctx->cache[ctx->n_cached];

      if (best == 0)

        ctx->n_miss = 0;

    } else 
if (630k
ctx->n_miss++ >= 630k
ISL_BLK_MAX_MISS630k
) {

      isl_blk_free_force(ctx, ctx->cache[0]);

      if (--ctx->n_cached != 0)

        ctx->cache[0] = ctx->cache[ctx->n_cached];

      ctx->n_miss = 0;

    }

  }

  return extend(ctx, block, n);

}

struct isl_blk isl_blk_extend(struct isl_ctx *ctx, struct isl_blk block,

        size_t new_n)

{

  if (isl_blk_is_empty(block))

    return isl_blk_alloc(ctx, new_n);

  return extend(ctx, block, new_n);

}

void isl_blk_free(struct isl_ctx *ctx, struct isl_blk block)

{

  if (isl_blk_is_empty(block) || 
isl_blk_is_error(block)18.1M
)

    return;

  if (ctx->n_cached < ISL_BLK_CACHE_SIZE)

    
ctx->cache[ctx->n_cached++] = block17.2M
;

  else

    isl_blk_free_force(ctx, block);

}

void isl_blk_clear_cache(struct isl_ctx *ctx)

{

  int i;

  for (i = 0; i < ctx->n_cached; 
++i24.0k
)

    isl_blk_free_force(ctx, ctx->cache[i]);

  ctx->n_cached = 0;

}