void gop_dummy_init()
{
//** Make the variables
assert_result(apr_pool_create(&gd_pool, NULL), APR_SUCCESS);
assert_result(apr_thread_mutex_create(&gd_lock, APR_THREAD_MUTEX_DEFAULT, gd_pool), APR_SUCCESS);
assert_result(apr_thread_cond_create(&gd_cond, gd_pool), APR_SUCCESS);
gd_stack = new_stack();
//** and launch the thread
thread_create_assert(&gd_thread, NULL, gd_thread_func, NULL, gd_pool);
}
cache_t *lru_cache_create(void *arg, data_attr_t *da, int timeout)
{
cache_t *cache;
cache_lru_t *c;
type_malloc_clear(cache, cache_t, 1);
type_malloc_clear(c, cache_lru_t, 1);
cache->fn.priv = c;
cache_base_create(cache, da, timeout);
cache->shutdown_request = 0;
c->stack = new_stack();
c->waiting_stack = new_stack();
c->pending_free_tasks = new_stack();
c->max_bytes = 100*1024*1024;
c->bytes_used = 0;
c->dirty_fraction = 0.1;
cache->n_ppages = 0;
cache->max_fetch_fraction = 0.1;
cache->max_fetch_size = cache->max_fetch_fraction * c->max_bytes;
cache->write_temp_overflow_used = 0;
cache->write_temp_overflow_fraction = 0.01;
cache->write_temp_overflow_size = cache->write_temp_overflow_fraction * c->max_bytes;
c->dirty_bytes_trigger = c->dirty_fraction * c->max_bytes;
c->dirty_max_wait = apr_time_make(1, 0);
c->flush_in_progress = 0;
c->limbo_pages = 0;
c->free_pending_tables = new_pigeon_coop("free_pending_tables", 50, sizeof(list_t *), cache->mpool, free_pending_table_new, free_pending_table_free);
c->free_page_tables = new_pigeon_coop("free_page_tables", 50, sizeof(page_table_t), cache->mpool, free_page_tables_new, free_page_tables_free);
cache->fn.create_empty_page = lru_create_empty_page;
cache->fn.adjust_dirty = lru_adjust_dirty;
cache->fn.destroy_pages = lru_pages_destroy;
cache->fn.cache_update = lru_update;
cache->fn.cache_miss_tag = lru_miss_tag;
cache->fn.s_page_access = lru_page_access;
cache->fn.s_pages_release = lru_pages_release;
cache->fn.destroy = lru_cache_destroy;
cache->fn.adding_segment = lru_adding_segment;
cache->fn.removing_segment = lru_removing_segment;
cache->fn.get_handle = cache_base_handle;
apr_thread_cond_create(&(c->dirty_trigger), cache->mpool);
thread_create_assert(&(c->dirty_thread), NULL, lru_dirty_thread, (void *)cache, cache->mpool);
return(cache);
}
data_service_fn_t *ds_ibp_create(void *arg, inip_file_t *ifd, char *section)
{
int cs_type;
data_service_fn_t *dsf;
ds_ibp_priv_t *ds;
ibp_context_t *ic;
type_malloc_clear(dsf, data_service_fn_t, 1);
type_malloc_clear(ds, ds_ibp_priv_t , 1);
//** Set the default attributes
memset(&(ds->attr_default), 0, sizeof(ds_ibp_attr_t));
ds->attr_default.attr.duration = inip_get_integer(ifd, section, "duration", 3600);
ds->warm_duration = ds->attr_default.attr.duration;
ds->warm_interval = 0.33 * ds->warm_duration;
ds->warm_interval = inip_get_integer(ifd, section, "warm_interval", ds->warm_interval);
ds->warm_duration = inip_get_integer(ifd, section, "warm_duration", ds->warm_duration);
cs_type = inip_get_integer(ifd, section, "chksum_type", CHKSUM_DEFAULT);
if ( ! ((chksum_valid_type(cs_type) == 0) || (cs_type == CHKSUM_DEFAULT) || (cs_type == CHKSUM_NONE))) {
log_printf(0, "Invalid chksum type=%d resetting to CHKSUM_DEFAULT(%d)\n", cs_type, CHKSUM_DEFAULT);
cs_type = CHKSUM_DEFAULT;
}
ds->attr_default.disk_cs_type = cs_type;
ds->attr_default.disk_cs_blocksize = inip_get_integer(ifd, section, "chksum_blocksize", 64*1024);
if (ds->attr_default.disk_cs_blocksize <= 0) {
log_printf(0, "Invalid chksum blocksize=" XOT " resetting to %d\n", ds->attr_default.disk_cs_blocksize, 64*1024);
ds->attr_default.disk_cs_blocksize = 64 *1024;
}
ds->attr_default.attr.reliability = IBP_HARD;
ds->attr_default.attr.type = IBP_BYTEARRAY;
//printf("cfg=%s sec=%s\n", config_file, section);
ic = ibp_create_context();
ibp_load_config(ic, ifd, section);
ds->ic = ic;
dsf->type = DS_TYPE_IBP;
dsf->priv = (void *)ds;
dsf->destroy_service = ds_ibp_destroy;
dsf->new_cap_set = ds_ibp_new_cap_set;
dsf->cap_auto_warm = ds_ibp_cap_auto_warm;
dsf->cap_stop_warm = ds_ibp_cap_stop_warm;
dsf->get_cap = ds_ibp_get_cap;
dsf->set_cap = ds_ibp_set_cap;
dsf->translate_cap_set = ds_ibp_translate_cap_set;
dsf->destroy_cap_set = ds_ibp_destroy_cap_set;
dsf->new_probe = ds_ibp_new_probe;
dsf->destroy_probe = ds_ibp_destroy_probe;
dsf->get_probe = ds_ibp_get_probe;
dsf->new_attr = ds_ibp_new_attr;
dsf->destroy_attr = ds_ibp_destroy_attr;
dsf->set_attr = ds_ibp_set_attr;
dsf->get_attr = ds_ibp_get_attr;
dsf->set_default_attr = ds_ibp_set_default_attr;
dsf->get_default_attr = ds_ibp_get_default_attr;
dsf->res2rid = ds_ibp_res2rid;
dsf->new_inquire = ds_ibp_new_inquire;
dsf->destroy_inquire = ds_ibp_destroy_inquire;
dsf->res_inquire_get = ds_ibp_res_inquire_get;
dsf->res_inquire = ds_ibp_res_inquire;
dsf->allocate = ds_ibp_allocate;
dsf->remove = ds_ibp_remove;
dsf->modify_count = ds_ibp_modify_count;
dsf->read = ds_ibp_read;
dsf->write = ds_ibp_write;
dsf->readv = ds_ibp_readv;
dsf->writev = ds_ibp_writev;
dsf->append = ds_ibp_append;
dsf->copy = ds_ibp_copy;
dsf->probe = ds_ibp_probe;
dsf->truncate = ds_ibp_truncate;
//** Launch the warmer
{ int result = apr_pool_create(&(ds->pool), NULL); assert(result == APR_SUCCESS); }
apr_thread_mutex_create(&(ds->lock), APR_THREAD_MUTEX_DEFAULT, ds->pool);
apr_thread_cond_create(&(ds->cond), ds->pool);
ds->warm_table = apr_hash_make(ds->pool);
thread_create_assert(&(ds->thread), NULL, ds_ibp_warm_thread, (void *)dsf, ds->pool);
return(dsf);
}
