void
slurmdrmaa_job_create_req(
fsd_drmaa_session_t *session,
const fsd_template_t *jt,
fsd_environ_t **envp,
job_desc_msg_t * job_desc,
int n_job /* ~job_step */
)
{
fsd_expand_drmaa_ph_t *volatile expand = NULL;
TRY
{
expand = fsd_expand_drmaa_ph_new( NULL, NULL, fsd_asprintf("%d",n_job) );
slurmdrmaa_job_create( session, jt, envp, expand, job_desc, n_job);
}
EXCEPT_DEFAULT
{
fsd_exc_reraise();
}
FINALLY
{
if( expand )
expand->destroy( expand );
}
END_TRY
}
struct submit *
lsfdrmaa_job_create_req(
fsd_drmaa_session_t *session,
const fsd_template_t *jt, fsd_environ_t **envp
)
{
struct submit *volatile req = NULL;
fsd_expand_drmaa_ph_t *volatile expand = NULL;
TRY
{
fsd_malloc( req, struct submit );
memset( req, 0, sizeof(struct submit) );
expand = fsd_expand_drmaa_ph_new( NULL, NULL, fsd_strdup("%I") );
lsfdrmaa_job_set_req( session, expand, jt, req, envp );
}
EXCEPT_DEFAULT
{
lsfdrmaa_free_submit_req( req, true );
fsd_exc_reraise();
}
FINALLY
{
if( expand )
expand->destroy( expand );
}
END_TRY
return req;
}
fsd_iter_t *
fsd_drmaa_session_run_bulk(
fsd_drmaa_session_t *self,
const fsd_template_t *jt,
int start, int end, int incr )
{
volatile unsigned n_jobs;
char **volatile result = NULL;
if( incr > 0 )
n_jobs = (end-start) / incr + 1;
else
n_jobs = (start-end) / -incr + 1;
TRY
{
unsigned i;
int idx;
fsd_calloc( result, n_jobs, char* );
for( i=0, idx=start; i < n_jobs; i++, idx+=incr )
result[i] = self->run_impl( self, jt, idx );
}
EXCEPT_DEFAULT
{
if( result )
fsd_free_vector( result );
fsd_exc_reraise();
}
END_TRY
return fsd_iter_new( result, -1 );
}
fsd_template_t *
fsd_template_new(
fsd_template_by_name_method *by_name_method,
fsd_template_by_code_method *by_code_method,
unsigned n_attributes
)
{
fsd_template_t *volatile self = NULL;
TRY
{
fsd_malloc( self, fsd_template_t );
self->attributes = NULL;
self->n_attributes = 0;
self->get_attr = fsd_template_get_attr;
self->set_attr = fsd_template_set_attr;
self->get_v_attr = fsd_template_get_v_attr;
self->set_v_attr = fsd_template_set_v_attr;
self->by_name = by_name_method;
self->by_code = by_code_method;
self->destroy = fsd_template_destroy;
fsd_calloc( self->attributes, n_attributes, void* );
self->n_attributes = n_attributes;
}
EXCEPT_DEFAULT
{
if( self )
self->destroy( self );
fsd_exc_reraise();
}
END_TRY
return self;
}
void
fsd_job_get_termination_status( fsd_job_t *self,
int *status, fsd_iter_t **rusage_out )
{
fsd_iter_t* volatile rusage = NULL;
TRY
{
if( rusage_out )
{
rusage = fsd_iter_new( NULL, 0 );
rusage->append( rusage, fsd_asprintf(
"submission_time=%ld", (long)self->submit_time ) );
if (self->start_time)
rusage->append( rusage, fsd_asprintf(
"start_time=%ld", (long)self->start_time ) );
if (self->end_time)
rusage->append( rusage, fsd_asprintf(
"end_time=%ld", (long)self->end_time ) );
rusage->append( rusage, fsd_asprintf(
"cpu=%ld", self->cpu_usage ) );
rusage->append( rusage, fsd_asprintf(
"mem=%ld", self->mem_usage ) );
rusage->append( rusage, fsd_asprintf(
"vmem=%ld", self->vmem_usage ) );
rusage->append( rusage, fsd_asprintf(
"walltime=%ld", self->walltime ) );
rusage->append( rusage, fsd_asprintf(
"hosts=%s", self->execution_hosts ) );
if (self->queue) {
rusage->append( rusage, fsd_asprintf("queue=%s", self->queue ) );
}
if (self->project) {
rusage->append( rusage, fsd_asprintf("project=%s", self->project ) );
}
}
}
EXCEPT_DEFAULT
{
if( rusage )
rusage->destroy( rusage );
if( rusage_out )
*rusage_out = NULL;
fsd_exc_reraise();
}
ELSE
{
if( status )
*status = self->exit_status;
if( rusage_out )
*rusage_out = rusage;
}
END_TRY
}
static char *
lsfdrmaa_job_quote_command( const char *const *argv )
{
char *volatile result = NULL;
TRY
{
size_t size = 0;
const char *const *i;
const char *j;
char *s;
for( i = argv; *i; i++ )
{
if( i != argv )
size++;
size += 2;
for( j = *i; *j; j++ )
switch( *j )
{
case '"': case '$': case '\\': case '`':
size ++;
default:
size ++;
break;
}
}
fsd_calloc( result, size+1, char );
s = result;
for( i = argv; *i; i++ )
{
if( i != argv )
*s++ = ' ';
*s++ = '"';
for( j = *i; *j; j++ )
switch( *j )
{
case '"': case '$': case '\\': case '`':
*s++ = '\\';
default:
*s++ = *j;
break;
}
*s++ = '"';
}
*s++ = '\0';
}
EXCEPT_DEFAULT
{
fsd_free( result );
fsd_exc_reraise();
}
END_TRY
return result;
}
fsd_job_t *
fsd_job_new( char *job_id )
{
fsd_job_t *volatile self = NULL;
fsd_log_enter(( "(%s)", job_id ));
TRY
{
fsd_malloc( self, fsd_job_t );
self->release = fsd_job_release;
self->destroy = fsd_job_destroy;
self->control = fsd_job_control;
self->update_status = fsd_job_update_status;
self->get_termination_status = fsd_job_get_termination_status;
self->on_missing = fsd_job_on_missing;
self->next = NULL;
self->ref_cnt = 1;
self->job_id = job_id;
self->session = NULL;
self->last_update_time = 0;
self->flags = 0;
self->state = DRMAA_PS_UNDETERMINED;
self->exit_status = 0;
self->submit_time = 0;
self->start_time = 0;
self->end_time = 0;
self->cpu_usage = 0;
self->mem_usage = 0;
self->vmem_usage = 0;
self->walltime = 0;
self->n_execution_hosts = 0;
self->execution_hosts = NULL;
self->retry_cnt = 0;
fsd_mutex_init( &self->mutex );
fsd_cond_init( &self->status_cond );
fsd_cond_init( &self->destroy_cond );
fsd_mutex_lock( &self->mutex );
}
EXCEPT_DEFAULT
{
if( self )
self->destroy( self );
else
fsd_free( job_id );
fsd_exc_reraise();
}
END_TRY
fsd_log_return(( "=%p: ref_cnt=%d [lock %s]",
(void*)self, self->ref_cnt, self->job_id ));
return self;
}
static fsd_iter_t *
fsd_iter_new_impl( char **list, int length, bool own )
{
fsd_iter_t *volatile self = NULL;
TRY
{
fsd_malloc( self, fsd_iter_t );
self->next = fsd_iter_next;
self->reset = fsd_iter_reset;
self->len = fsd_iter_len;
self->append = fsd_iter_append;
self->destroy = fsd_iter_destroy;
self->_list = list;
self->_position = 0;
if( list == NULL )
self->_length = 0;
else if( length >= 0 )
self->_length = length;
else
{
char **i;
int cnt = 0;
for( i = self->_list; *i != NULL; i++ )
cnt++;
self->_length = cnt;
}
self->_own_list = own;
}
EXCEPT_DEFAULT
{
if( own && list )
{
if( length >= 0 )
{
int i;
for( i = 0; i < length; i++ )
fsd_free( list[i] );
fsd_free( list );
}
else
fsd_free_vector( list );
}
fsd_exc_reraise();
}
END_TRY
return self;
}
fsd_job_set_t *
fsd_job_set_new(void)
{
fsd_job_set_t *volatile self = NULL;
const size_t initial_size = 1024;
fsd_log_enter(( "()" ));
TRY
{
fsd_malloc( self, fsd_job_set_t );
self->destroy = fsd_job_set_destroy;
self->add = fsd_job_set_add;
self->remove = fsd_job_set_remove;
self->get = fsd_job_set_get;
self->empty = fsd_job_set_empty;
self->find_terminated = fsd_job_set_find_terminated;
self->get_all_job_ids = fsd_job_set_get_all_job_ids;
self->signal_all = fsd_job_set_signal_all;
self->tab = NULL;
self->n_jobs = 0;
fsd_calloc( self->tab, initial_size, fsd_job_t* );
self->tab_size = initial_size;
self->tab_mask = self->tab_size - 1;
fsd_mutex_init( &self->mutex );
}
EXCEPT_DEFAULT
{
if( self )
{
fsd_free( self->tab );
fsd_free( self );
}
fsd_exc_reraise();
}
END_TRY
fsd_log_return(( " =%p", (void*)self ));
return self;
}
fsd_drmaa_session_t *
slurmdrmaa_session_new( const char *contact )
{
slurmdrmaa_session_t *volatile self = NULL;
TRY
{
self = (slurmdrmaa_session_t*)fsd_drmaa_session_new(contact);
fsd_realloc( self, 1, slurmdrmaa_session_t );
self->super.run_job = slurmdrmaa_session_run_job;
self->super.run_bulk = slurmdrmaa_session_run_bulk;
self->super.new_job = slurmdrmaa_session_new_job;
self->super.load_configuration( &self->super, "slurm_drmaa" );
}
EXCEPT_DEFAULT
{
fsd_free( self );
fsd_exc_reraise();
}
END_TRY
return (fsd_drmaa_session_t*)self;
}
char *
fsd_drmaa_session_wait_for_any_job(
fsd_drmaa_session_t *self,
const struct timespec *timeout,
int *status, fsd_iter_t **rusage,
bool dispose
)
{
fsd_job_set_t *set = self->jobs;
fsd_job_t *volatile job = NULL;
char *volatile job_id = NULL;
volatile bool locked = false;
fsd_log_enter(( "" ));
TRY
{
while( job == NULL )
{
bool signaled = true;
if( self->destroy_requested )
fsd_exc_raise_code( FSD_DRMAA_ERRNO_NO_ACTIVE_SESSION );
if( !self->enable_wait_thread )
self->update_all_jobs_status( self );
locked = fsd_mutex_lock( &self->mutex );
if( set->empty( set ) )
fsd_exc_raise_msg( FSD_DRMAA_ERRNO_INVALID_JOB,
"No job found to be waited for" );
if( (job = set->find_terminated( set )) != NULL )
break;
if( self->destroy_requested )
fsd_exc_raise_code( FSD_DRMAA_ERRNO_NO_ACTIVE_SESSION );
if( self->enable_wait_thread )
{
fsd_log_debug(( "wait_for_any_job: waiting for wait thread" ));
if( timeout )
signaled = fsd_cond_timedwait(
&self->wait_condition, &self->mutex, timeout );
else
fsd_cond_wait( &self->wait_condition, &self->mutex );
}
else
{
fsd_log_debug(( "wait_for_any_job: waiting for next check" ));
self->wait_for_job_status_change( self,
&self->wait_condition, &self->mutex, timeout );
}
locked = fsd_mutex_unlock( &self->mutex );
fsd_log_debug((
"wait_for_any_job: woken up; signaled=%d", signaled ));
if( !signaled )
fsd_exc_raise_code( FSD_DRMAA_ERRNO_EXIT_TIMEOUT );
}
fsd_log_debug(( "wait_for_any_job: waiting finished" ));
job_id = fsd_strdup( job->job_id );
job->get_termination_status( job, status, rusage );
}
EXCEPT_DEFAULT
{
if( job_id )
fsd_free( job_id );
fsd_exc_reraise();
}
FINALLY
{
if( job )
{
if( fsd_exc_get() == NULL && dispose )
{
set->remove( set, job );
job->flags |= FSD_JOB_DISPOSED;
}
job->release( job );
}
if( locked )
fsd_mutex_unlock( &self->mutex );
}
END_TRY
fsd_log_return(( " =%s", job_id ));
return job_id;
}
fsd_drmaa_session_t *
fsd_drmaa_session_new( const char *contact )
{
fsd_drmaa_session_t *volatile self = NULL;
fsd_log_enter(( "(%s)", contact ));
TRY
{
fsd_malloc( self, fsd_drmaa_session_t );
self->release = fsd_drmaa_session_release;
self->destroy = fsd_drmaa_session_destroy;
self->destroy_nowait = fsd_drmaa_session_destroy_nowait;
self->run_job = fsd_drmaa_session_run_job;
self->run_bulk = fsd_drmaa_session_run_bulk;
self->control_job = fsd_drmaa_session_control_job;
self->job_ps = fsd_drmaa_session_job_ps;
self->synchronize = fsd_drmaa_session_synchronize;
self->wait = fsd_drmaa_session_wait;
self->new_job = fsd_drmaa_session_new_job;
self->run_impl = fsd_drmaa_session_run_impl;
self->wait_for_single_job = fsd_drmaa_session_wait_for_single_job;
self->wait_for_any_job = fsd_drmaa_session_wait_for_any_job;
self->wait_for_job_status_change =
fsd_drmaa_session_wait_for_job_status_change;
self->wait_thread = fsd_drmaa_session_wait_thread;
self->stop_wait_thread = fsd_drmaa_session_stop_wait_thread;
self->update_all_jobs_status = fsd_drmaa_session_update_all_jobs_status;
self->get_submited_job_ids = fsd_drmaa_session_get_submited_job_ids;
self->get_job = fsd_drmaa_session_get_job;
self->load_configuration = fsd_drmaa_session_load_configuration;
self->read_configuration = fsd_drmaa_session_read_configuration;
self->apply_configuration = fsd_drmaa_session_apply_configuration;
self->ref_cnt = 1;
self->destroy_requested = false;
self->contact = NULL;
self->jobs = NULL;
self->configuration = NULL;
self->pool_delay.tv_sec = 5;
self->pool_delay.tv_nsec = 0;
self->cache_job_state = 0;
self->enable_wait_thread = true;
self->job_categories = NULL;
self->missing_jobs = FSD_REVEAL_MISSING_JOBS;
self->wait_thread_started = false;
self->wait_thread_run_flag = false;
fsd_mutex_init( &self->mutex );
fsd_cond_init( &self->wait_condition );
fsd_cond_init( &self->destroy_condition );
fsd_mutex_init( &self->drm_connection_mutex );
self->jobs = fsd_job_set_new();
self->contact = fsd_strdup( contact );
}
EXCEPT_DEFAULT
{
if( self != NULL )
self->destroy( self );
fsd_exc_reraise();
}
END_TRY
fsd_log_debug(("sizeof(fsd_drmaa_session_t)=%d", sizeof(fsd_drmaa_session_t)));
return self;
}