extern int main(void)
{
cl_thread_settings_t* thread_p = NULL;
cl_thread_settings_t* dummy_thread_p = NULL;
int count = 0;
/* setup thread list */
cl_thread_list_setup(&thread_list,"thread list");
/* setup first thread */
cl_thread_list_create_thread(thread_list, &dummy_thread_p,NULL, "1st thread", 1, my_thread, NULL, NULL, CL_TT_USER1);
/* setup second thread */
cl_thread_list_create_thread(thread_list, &dummy_thread_p, NULL, "2nd thread", 2, my_thread, NULL, NULL, CL_TT_USER1);
thread_p = cl_thread_list_get_thread_by_id(thread_list, 1);
printf("first thread (%s) has id: %d\n", thread_p->thread_name, thread_p->thread_id);
thread_p = cl_thread_list_get_thread_by_name(thread_list, "2nd thread");
printf("second thread (%s) has id: %d\n" , thread_p->thread_name, thread_p->thread_id);
while (count++ < 10) {
int id;
printf("we have %ld threads.\n", cl_raw_list_get_elem_count(thread_list));
thread_p = cl_thread_list_get_first_thread(thread_list);
id = thread_p->thread_id;
printf("-----------> delete thread %d ...\n", id);
cl_thread_list_delete_thread_by_id(thread_list, id);
printf("<----------- delete thread %d done\n", id);
printf("-----------> add thread ...\n");
cl_thread_list_create_thread(thread_list, &dummy_thread_p, NULL,"new thread", id, my_thread, NULL, NULL, CL_TT_USER1);
printf("<----------- add thread done\n");
}
/* delete all threads */
while ( (thread_p=cl_thread_list_get_first_thread(thread_list)) != NULL ) {
int id = thread_p->thread_id;
printf("-----------> delete thread %d ...\n",id );
cl_thread_list_delete_thread(thread_list, thread_p);
printf("<----------- delete thread %d done\n",id );
}
cl_thread_list_cleanup(&thread_list);
printf("main done\n");
return 0;
}
void
sge_worker_initialize(sge_gdi_ctx_class_t *ctx)
{
const u_long32 max_initial_worker_threads = ctx->get_worker_thread_count(ctx);
cl_thread_settings_t* dummy_thread_p = NULL;
int i;
DENTER(TOP_LAYER, "sge_worker_initialize");
/*
* TODO: EB: corresponding destroy function is missing during shutdown
*/
sge_tq_create(&Master_Task_Queue);
sge_init_job_number();
sge_init_ar_id();
DPRINTF(("job/ar counter have been initialized\n"));
reporting_initialize(NULL);
DPRINTF(("accounting and reporting module has been initialized\n"));
INFO((SGE_EVENT, MSG_QMASTER_THREADCOUNT_US,
sge_u32c(max_initial_worker_threads), threadnames[WORKER_THREAD]));
cl_thread_list_setup(&(Main_Control.worker_thread_pool), "thread pool");
for (i = 0; i < max_initial_worker_threads; i++) {
dstring thread_name = DSTRING_INIT;
sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[WORKER_THREAD], i);
cl_thread_list_create_thread(Main_Control.worker_thread_pool, &dummy_thread_p,
cl_com_get_log_list(), sge_dstring_get_string(&thread_name), i,
sge_worker_main, NULL, NULL, CL_TT_WORKER);
sge_dstring_free(&thread_name);
}
DRETURN_VOID;
}
void
sge_signaler_initialize(sge_gdi_ctx_class_t *ctx)
{
cl_thread_settings_t* dummy_thread_p = NULL;
dstring thread_name = DSTRING_INIT;
DENTER(TOP_LAYER, "sge_signaler_initialize");
sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[SIGNALER_THREAD], 0);
cl_thread_list_setup(&(Main_Control.signal_thread_pool), "signal thread pool");
cl_thread_list_create_thread(Main_Control.signal_thread_pool, &dummy_thread_p,
cl_com_get_log_list(), sge_dstring_get_string(&thread_name), 0,
sge_signaler_main, NULL, NULL, CL_TT_SIGNALER);
sge_dstring_free(&thread_name);
DRETURN_VOID;
}
void
sge_event_master_initialize(sge_gdi_ctx_class_t *ctx)
{
cl_thread_settings_t* dummy_thread_p = NULL;
dstring thread_name = DSTRING_INIT;
DENTER(TOP_LAYER, "sge_event_master_initialize");
DPRINTF(("event master functionality has been initialized\n"));
sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[DELIVERER_THREAD], 0);
cl_thread_list_setup(&(Main_Control.event_master_thread_pool), "event master thread pool");
cl_thread_list_create_thread(Main_Control.event_master_thread_pool, &dummy_thread_p,
cl_com_get_log_list(), sge_dstring_get_string(&thread_name), 0,
sge_event_master_main, NULL, NULL, CL_TT_DELIVERER);
sge_dstring_free(&thread_name);
DRETURN_VOID;
}
extern int main(int argc, char** argv)
{
cl_raw_list_t* log_list = NULL;
cl_thread_settings_t* thread_p = NULL;
cl_thread_settings_t* log_thread = NULL;
cl_thread_settings_t* dummy_thread_p = NULL;
int count = 2;
if (argc != 2) {
printf("please enter 0 for standard log function, 1 for special\n");
exit(1);
}
/* setup log list */
if (atoi(argv[1]) == 0) {
cl_log_list_setup(&log_list,"application",0,CL_LOG_IMMEDIATE, NULL);
} else {
cl_log_list_setup(&log_list,"application",0,CL_LOG_IMMEDIATE, my_log_flush_list);
}
/* setup log thread */
log_thread = (cl_thread_settings_t*) malloc(sizeof(cl_thread_settings_t));
cl_thread_setup(log_thread, log_list, "log thread", 1,my_log_thread, NULL, NULL, CL_TT_USER1);
cl_log_list_set_log_level(log_list,CL_LOG_DEBUG );
/* setup thread list */
cl_thread_list_setup(&thread_list,"thread list");
/* setup first thread */
cl_thread_list_create_thread(thread_list, &dummy_thread_p, log_list, "1st thread", 1, my_test_thread, NULL, NULL, CL_TT_USER1);
/* setup second thread */
cl_thread_list_create_thread(thread_list, &dummy_thread_p, log_list, "2nd thread", 2, my_test_thread, NULL, NULL, CL_TT_USER1);
thread_p = cl_thread_list_get_thread_by_id(thread_list, 1);
CL_LOG_STR( CL_LOG_INFO, "My thread name is ", thread_p->thread_name );
thread_p = cl_thread_list_get_thread_by_name(thread_list, "2nd thread");
CL_LOG_STR( CL_LOG_INFO, "My thread name is ", thread_p->thread_name );
while ( count < 10 ) {
int id;
char new_thread_name[255];
count++;
CL_LOG_INT(CL_LOG_INFO, "number of threads: ", (int)cl_raw_list_get_elem_count(thread_list) );
thread_p = cl_thread_list_get_first_thread(thread_list);
id = thread_p->thread_id;
CL_LOG_INT( CL_LOG_INFO, "delete thread: ", id );
cl_thread_list_delete_thread_by_id(thread_list, id);
CL_LOG_INT(CL_LOG_INFO, "thread deleted, id: ", id );
sprintf(new_thread_name,"thread nr %d", count);
CL_LOG( CL_LOG_INFO, "adding thread ...");
cl_thread_list_create_thread(thread_list,&dummy_thread_p, log_list,new_thread_name, id, my_test_thread, NULL, NULL, CL_TT_USER1);
CL_LOG( CL_LOG_INFO, "adding thread done");
}
/* remove all threads from thread list */
while ( (thread_p=cl_thread_list_get_first_thread(thread_list)) != NULL ) {
int id = thread_p->thread_id;
CL_LOG_INT( CL_LOG_INFO, "delete thread: ", id );
CL_LOG_INT( CL_LOG_INFO, "event calls: ", (int)thread_p->thread_event_count );
cl_thread_list_delete_thread_by_id(thread_list, id);
CL_LOG_INT( CL_LOG_INFO, "thread deleted, id: ", id );
}
CL_LOG_INT( CL_LOG_INFO, "log event calls: ", (int)log_thread->thread_event_count );
CL_LOG( CL_LOG_INFO, "cleaning up thread list");
cl_thread_list_cleanup(&thread_list);
/* shutdown of log thread */
cl_thread_shutdown(log_thread);
cl_thread_join(log_thread);
cl_thread_cleanup(log_thread);
free(log_thread);
/* cleanup log list */
CL_LOG( CL_LOG_INFO, "cleaning up log list");
printf( "cl_log_list_cleanup() returned: %s\n", cl_get_error_text(cl_log_list_cleanup(&log_list)));
printf("main done\n");
return 0;
}
/****** qmaster/threads/sge_scheduler_initialize() ***************************
* NAME
* sge_scheduler_initialize() -- setup and start the scheduler thread
*
* SYNOPSIS
* void sge_scheduler_initialize(sge_gdi_ctx_class_t *ctx)
*
* FUNCTION
* A call to this function initializes the scheduler thread if it is
* not already running.
*
* The first call to this function (during qmaster qstart) starts
* the scheduler thread only if it is enabled in the bootstrap file.
* Otherwise the scheduler will not be started.
*
* Each subsequent call (triggered from GDI) will definitely start
* the scheduler thread if it is not running.
*
* Main routine for the created thread is sge_scheduler_main().
*
* 'Master_Scheduler' is accessed by this function.
*
* INPUTS
* sge_gdi_ctx_class_t *ctx - context object
* lList **answer_list - answer list
*
* RESULT
* void - None
*
* NOTES
* MT-NOTE: sge_scheduler_initialize() is MT safe
*
* SEE ALSO
* qmaster/threads/sge_scheduler_initialize()
* qmaster/threads/sge_scheduler_cleanup_thread()
* qmaster/threads/sge_scheduler_terminate()
* qmaster/threads/sge_scheduler_main()
*******************************************************************************/
void
sge_scheduler_initialize(sge_gdi_ctx_class_t *ctx, lList **answer_list)
{
DENTER(TOP_LAYER, "sge_scheduler_initialize");
/* initialize debugging instrumentation */
{
char *debug = getenv("SGE_TEST_DELAY_SCHEDULING");
if (debug != NULL) {
SGE_TEST_DELAY_SCHEDULING = atoi(debug);
}
}
sge_mutex_lock("master scheduler struct", SGE_FUNC, __LINE__, &(Master_Scheduler.mutex));
if (Master_Scheduler.is_running == false) {
bool start_thread = true;
/*
* when this function is called the first time we will use the setting from
* the bootstrap file to identify if the scheduler should be started or not
* otherwise we have to start the thread due to a manual request through GDI.
* There is no option. We have to start it.
*/
if (Master_Scheduler.use_bootstrap == true) {
start_thread = ((ctx->get_scheduler_thread_count(ctx) > 0) ? true : false);
Master_Scheduler.use_bootstrap = false;
}
if (start_thread == true) {
cl_thread_settings_t* dummy_thread_p = NULL;
dstring thread_name = DSTRING_INIT;
/*
* initialize the thread pool
*/
cl_thread_list_setup(&(Main_Control.scheduler_thread_pool), "thread pool");
/*
* prepare a unique scheduler thread name for each instance of an scheduler
*/
sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[SCHEDD_THREAD],
Master_Scheduler.thread_id);
/*
* start the scheduler
*/
cl_thread_list_create_thread(Main_Control.scheduler_thread_pool, &dummy_thread_p,
cl_com_get_log_list(), sge_dstring_get_string(&thread_name),
Master_Scheduler.thread_id, sge_scheduler_main, NULL, NULL, CL_TT_SCHEDULER);
sge_dstring_free(&thread_name);
/*
* Increase the thread id so that the next instance of a scheduler will have a
* different name and flag that scheduler is running
*/
Master_Scheduler.thread_id++;
Master_Scheduler.is_running = true;
INFO((SGE_EVENT, MSG_THREAD_XHASSTARTED_S, threadnames[SCHEDD_THREAD]));
answer_list_add(answer_list, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_INFO);
} else {
INFO((SGE_EVENT, MSG_THREAD_XSTARTDISABLED_S, threadnames[SCHEDD_THREAD]));
answer_list_add(answer_list, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_INFO);
}
} else {
ERROR((SGE_EVENT, MSG_THREAD_XISRUNNING_S, threadnames[SCHEDD_THREAD]));
answer_list_add(answer_list, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
}
sge_mutex_unlock("master scheduler struct", SGE_FUNC, __LINE__, &(Master_Scheduler.mutex));
DRETURN_VOID;
}
