/****** spool/berkeleydb/bdb_set_txn() ***************************************** * NAME * bdb_set_txn() -- store a transaction handle * * SYNOPSIS * void * bdb_set_txn(bdb_info info, DB_TXN *txn) * * FUNCTION * Stores a Berkeley DB transaction handle. * It is always stored in thread local storage. * * INPUTS * bdb_info info - the database object * DB_TXN *txn - the transaction handle to store * * NOTES * MT-NOTE: bdb_set_txn() is MT safe * * SEE ALSO * spool/berkeleydb/bdb_get_txn() *******************************************************************************/ void bdb_set_txn(bdb_info info, DB_TXN *txn) { GET_SPECIFIC(bdb_connection, con, bdb_init_connection, info->key, "bdb_set_txn"); con->txn = txn; }
/****** spool/berkeleydb/bdb_get_txn() ***************************************** * NAME * bdb_get_txn() -- get a transaction handle * * SYNOPSIS * DB_TXN * * bdb_get_txn(bdb_info info) * * FUNCTION * Returns a transaction handle set earlier with bdb_set_txn(). * Each thread can have one transaction open. * * INPUTS * bdb_info info - the database object * * RESULT * DB_TXN * - a transaction handle * * NOTES * MT-NOTE: bdb_get_txn() is MT safe * * SEE ALSO * spool/berkeleydb/bdb_set_txn() *******************************************************************************/ DB_TXN * bdb_get_txn(bdb_info info) { GET_SPECIFIC(bdb_connection, con, bdb_init_connection, info->key, "bdb_get_txn"); return con->txn; }
const char *bootstrap_get_default_domain(void) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_get_default_domain"); bootstrap = handle->current; return bootstrap->get_default_domain(bootstrap); }
bool bootstrap_get_job_spooling(void) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_get_job_spooling"); bootstrap = handle->current; return bootstrap->get_job_spooling(bootstrap); }
void bootstrap_set_job_spooling(bool value) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_set_job_spooling"); bootstrap = handle->current; bootstrap->set_job_spooling(bootstrap, value ); }
void bootstrap_set_jvm_thread_count(int value) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_set_jvm_thread_count"); bootstrap = handle->current; bootstrap->set_jvm_thread_count(bootstrap, value); }
int bootstrap_get_jvm_thread_count(void) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_get_jvm_thread_count"); bootstrap = handle->current; return bootstrap->get_jvm_thread_count(bootstrap); }
void bootstrap_set_qmaster_spool_dir(const char *value) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_set_qmaster_spool_dir"); bootstrap = handle->current; bootstrap->set_qmaster_spool_dir(bootstrap, value); }
void bootstrap_set_security_mode(const char *value) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_set_security_mode"); bootstrap = handle->current; bootstrap->set_security_mode(bootstrap, value ); }
const char *bootstrap_get_qmaster_spool_dir(void) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_get_qmaster_spool_dir"); bootstrap = handle->current; return bootstrap->get_qmaster_spool_dir(bootstrap); }
const char *bootstrap_get_security_mode(void) { sge_bootstrap_state_class_t* bootstrap = NULL; GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "bootstrap_get_security_mode"); bootstrap = handle->current; return bootstrap->get_security_mode(bootstrap); }
/****** spool/berkeleydb/bdb_set_env() ***************************************** * NAME * bdb_set_env() -- set the Berkeley DB environment * * SYNOPSIS * void * bdb_set_env(bdb_info info, DB_ENV *env) * * FUNCTION * Sets the Berkeley DB environment. * If the RPC mechanism is used, an environment has to be created and opened * per thread. * * INPUTS * bdb_info info - the database object * DB_ENV *env - the environment handle to set * * NOTES * MT-NOTE: bdb_set_env() is MT safe * * SEE ALSO * spool/berkeleydb/bdb_get_env() *******************************************************************************/ void bdb_set_env(bdb_info info, DB_ENV *env) { if (info->server == NULL) { info->env = env; } else { GET_SPECIFIC(bdb_connection, con, bdb_init_connection, info->key, "bdb_set_env"); con->env = env; } }
/****** spool/berkeleydb/bdb_set_db() ****************************************** * NAME * bdb_set_db() -- set a Berkeley DB database handle * * SYNOPSIS * void * bdb_set_db(bdb_info info, DB *db) * * FUNCTION * Sets the Berkeley DB database handle. * If the RPC mechanism is used, a database handle has to be created and * opened per thread. * * INPUTS * bdb_info info - the database object * DB *db - the database handle to store * * NOTES * MT-NOTE: bdb_set_db() is MT safe * * SEE ALSO * spool/berkeleydb/bdb_get_db() *******************************************************************************/ void bdb_set_db(bdb_info info, DB *db, const bdb_database database) { if (info->server == NULL) { info->db[database] = db; } else { GET_SPECIFIC(bdb_connection, con, bdb_init_connection, info->key, "bdb_set_db"); con->db[database] = db; } }
void sge_bootstrap_state_set_thread_local(sge_bootstrap_state_class_t* ctx) { DENTER(TOP_LAYER, "sge_bootstrap_state_set_thread_local"); { GET_SPECIFIC(sge_bootstrap_thread_local_t, handle, bootstrap_thread_local_init, sge_bootstrap_thread_local_key, "sge_bootstrap_state_set_thread_local"); if (ctx != NULL) { handle->current = ctx; } else { handle->current = handle->original; } } DEXIT; }
/****** spool/berkeleydb/bdb_get_env() ***************************************** * NAME * bdb_get_env() -- get Berkeley DB database environment * * SYNOPSIS * DB_ENV * bdb_get_env(bdb_info info) * * FUNCTION * Returns the Berkeley DB database environment set earlier using * bdb_set_env(). * If the RPC mechanism is used, the environment is stored per thread. * * INPUTS * bdb_info info - the database object * * RESULT * DB_ENV * - the database environment * * NOTES * MT-NOTE: bdb_get_env() is MT safe * * SEE ALSO * spool/berkeleydb/bdb_set_env() *******************************************************************************/ DB_ENV * bdb_get_env(bdb_info info) { DB_ENV *env = NULL; if (info->server == NULL) { env = info->env; } else { GET_SPECIFIC(bdb_connection, con, bdb_init_connection, info->key, "bdb_get_env"); env = con->env; } return env; }
/****** spool/berkeleydb/bdb_get_db() ****************************************** * NAME * bdb_get_db() -- get Berkeley DB database handle * * SYNOPSIS * DB * * bdb_get_db(bdb_info info) * * FUNCTION * Return the Berkeleyd BD database handle set earlier using bdb_set_db(). * If the RPC mechanism is used, the database handle is stored per thread. * * INPUTS * bdb_info info - the database object * * RESULT * DB * - the database handle * * NOTES * MT-NOTE: bdb_get_db() is MT safe * * SEE ALSO * spool/berkeleydb/bdb_set_db() *******************************************************************************/ DB * bdb_get_db(bdb_info info, const bdb_database database) { DB *db = NULL; if (info->server == NULL) { db = info->db[database]; } else { GET_SPECIFIC(bdb_connection, con, bdb_init_connection, info->key, "bdb_get_db"); db = con->db[database]; } return db; }
/****** test_sge_lock_multiple/thread_function() ********************************* * NAME * thread_function() -- Thread function to execute * * SYNOPSIS * static void* thread_function(void *anArg) * * FUNCTION * Acquire multiple locks and sleep. Release the locks. After each 'sge_lock()' * and 'sge_unlock()' sleep to increase the probability of interlocked execution. * Note that we deliberately test the boundaries of 'sge_locktype_t'. * * INPUTS * void *anArg - thread function arguments * * RESULT * static void* - none * * SEE ALSO * test_sge_lock_multiple/get_thrd_func() *******************************************************************************/ static void *thread_function(void *anArg) { struct timeval before; struct timeval after; double time_new; int i; int max = 1000000; int test = 257; int result; DENTER(TOP_LAYER, "thread_function"); has_finished("start",0.0); gettimeofday(&before, NULL); for (i = 0; i < max; i++) { result = test +1; test = result +1; } gettimeofday(&after, NULL); time_new = after.tv_usec - before.tv_usec; time_new = after.tv_sec - before.tv_sec + (time_new/1000000); has_finished("variable access", time_new); gettimeofday(&before, NULL); for (i = 0; i < max; i++) { GET_SPECIFIC(state_t, state, state_init, state_key, "test_sge_lock_multiple"); state->value2 = state->value +1; state->value = state->value2 +1; } gettimeofday(&after, NULL); time_new = after.tv_usec - before.tv_usec; time_new = after.tv_sec - before.tv_sec + (time_new/1000000); has_finished("thread local ", time_new); gettimeofday(&before, NULL); for (i = 0; i < max; i++) { pthread_once(&log_once, log_once_init); { GET_SPECIFIC(state_t, state, state_init, state_key, "test_sge_lock_multiple"); state->value2 = state->value +1; state->value = state->value2 +1; } } gettimeofday(&after, NULL); time_new = after.tv_usec - before.tv_usec; time_new = after.tv_sec - before.tv_sec + (time_new/1000000); has_finished("thread local once ", time_new); gettimeofday(&before, NULL); for (i = 0; i < max; i++) { sge_mutex_lock("mutex", SGE_FUNC, __LINE__, &mutex); result = test +1; test = result +1; sge_mutex_unlock("mutex", SGE_FUNC, __LINE__, &mutex); } gettimeofday(&after, NULL); time_new = after.tv_usec - before.tv_usec; time_new = after.tv_sec - before.tv_sec + (time_new/1000000); has_finished("mutex ", time_new); gettimeofday(&before, NULL); for (i = 0; i < max; i++) { SGE_LOCK(LOCK_GLOBAL, LOCK_READ); result = test +1; test = result +1; SGE_UNLOCK(LOCK_GLOBAL, LOCK_READ); } gettimeofday(&after, NULL); time_new = after.tv_usec - before.tv_usec; time_new = after.tv_sec - before.tv_sec + (time_new/1000000); has_finished("read lock ", time_new); gettimeofday(&before, NULL); for (i = 0; i < max; i++) { SGE_LOCK(LOCK_GLOBAL, LOCK_WRITE); result = test +1; test = result +1; SGE_UNLOCK(LOCK_GLOBAL, LOCK_WRITE); } gettimeofday(&after, NULL); time_new = after.tv_usec - before.tv_usec; time_new = after.tv_sec - before.tv_sec + (time_new/1000000); has_finished("write lock ", time_new); DEXIT; return (void *)NULL; } /* thread_function */