char *
fsd_drmaa_session_run_impl(
fsd_drmaa_session_t *self,
const fsd_template_t *jt, int bulk_incr )
{
fsd_exc_raise_code( FSD_ERRNO_NOT_IMPLEMENTED );
}
void
fsd_job_set_remove( fsd_job_set_t *self, fsd_job_t *job )
{
fsd_job_t **pjob = NULL;
uint32_t h;
fsd_log_enter(( "(job_id=%s)", job->job_id ));
fsd_mutex_lock( &self->mutex );
TRY
{
h = hashstr( job->job_id, strlen(job->job_id), 0 );
h &= self->tab_mask;
for( pjob = &self->tab[ h ]; *pjob; pjob = &(*pjob)->next )
{
if( *pjob == job )
break;
}
if( *pjob )
{
*pjob = (*pjob)->next;
job->next = NULL;
self->n_jobs--;
job->ref_cnt--;
}
else
fsd_exc_raise_code( FSD_DRMAA_ERRNO_INVALID_JOB );
}
FINALLY
{ fsd_mutex_unlock( &self->mutex ); }
END_TRY
fsd_log_return(( ": job->ref_cnt=%d", job->ref_cnt ));
}
void
fsd_drmaa_session_wait_for_job_status_change(
fsd_drmaa_session_t *self,
fsd_cond_t *wait_condition,
fsd_mutex_t *mutex,
const struct timespec *timeout
)
{
struct timespec ts, *next_check = &ts;
bool status_changed;
if( timeout )
fsd_log_enter((
"(timeout=%ld.%09ld)",
timeout->tv_sec, timeout->tv_nsec ));
else
fsd_log_enter(( "(timeout=(null))" ));
fsd_get_time( next_check );
fsd_ts_add( next_check, &self->pool_delay );
if( timeout && fsd_ts_cmp( timeout, next_check ) < 0 )
next_check = (struct timespec*)timeout;
fsd_log_debug(( "wait_for_job_status_change: waiting untill %ld.%09ld",
next_check->tv_sec, next_check->tv_nsec ));
status_changed = fsd_cond_timedwait(
wait_condition, mutex, next_check );
if( !status_changed && next_check == timeout )
fsd_exc_raise_code( FSD_DRMAA_ERRNO_EXIT_TIMEOUT );
fsd_log_return(( ": next_check=%ld.%09ld, status_changed=%d",
next_check->tv_sec, next_check->tv_nsec,
(int)status_changed
));
}
static void
fsd_template_set_attr( fsd_template_t *self,
const char *name, const char *value )
{
const fsd_attribute_t *attr = NULL;
fsd_log_enter(("(%s=%s)", name, value));
if( name == NULL )
fsd_exc_raise_code( FSD_ERRNO_INVALID_ARGUMENT );
attr = self->by_name( self, name );
if( attr == NULL || attr->is_vector )
fsd_exc_raise_fmt(
FSD_ERRNO_INVALID_ARGUMENT,
"invalid scalar attribute name: %s", name
);
if( value != NULL ) {
if (strlen (value) > DRMAA_MAX_ATTR_LEN)
fsd_exc_raise_fmt(
FSD_ERRNO_INVALID_ARGUMENT,
"Argument length exceeds max size: %d > %d", (int)strlen(value), DRMAA_MAX_ATTR_LEN
);
if( self->attributes[ attr->code ] != NULL ) {
fsd_free(self->attributes[ attr->code ]);
}
self->attributes[ attr->code ] = fsd_strdup( value );
}
else
self->attributes[ attr->code ] = NULL;
}
static void
fsd_template_set_v_attr( fsd_template_t *self,
const char *name, const char **value )
{
const fsd_attribute_t *attr = NULL;
char **volatile v = NULL;
if( name == NULL )
fsd_exc_raise_code( FSD_ERRNO_INVALID_ARGUMENT );
attr = self->by_name( self, name );
if( attr == NULL || ! attr->is_vector )
fsd_exc_raise_fmt(
FSD_ERRNO_INVALID_ARGUMENT,
"invalid vector attribute name: %s", name
);
TRY
{
int code = attr->code;
if( value != NULL )
v = fsd_copy_vector( value );
if( self->attributes[code] != NULL )
fsd_free_vector( self->attributes[code] );
self->attributes[code] = v; v = NULL;
}
FINALLY
{ fsd_free_vector( v ); }
END_TRY
}
static const char *
fsd_iter_next( fsd_iter_t *self )
{
if( self->_position < self->_length )
return self->_list[ self->_position++ ];
else
fsd_exc_raise_code( FSD_ERRNO_STOP_ITERATION );
}
static void
lsfdrmaa_job_update_status( fsd_job_t *self )
{
lsfdrmaa_job_t *lsf_self = (lsfdrmaa_job_t*)self;
struct jobInfoEnt *volatile job_info = NULL;
bool job_in_queue;
fsd_log_enter(( "({job_id=%s, time_delta=%d})", self->job_id, time(NULL) - self->submit_time ));
do {
fsd_mutex_lock( &self->session->drm_connection_mutex );
TRY
{
int n_records;
int more;
char * username = (lsf_self->int_job_id>0)?"all":NULL;
fsd_log_debug(( "drm connection locked" ));
n_records = lsb_openjobinfo( lsf_self->int_job_id,
NULL, username, NULL, NULL, ALL_JOB );
fsd_log_debug((
"lsb_openjobinfo( %d[%d], NULL, %s, NULL, NULL, ALL_JOB ) =%d",
LSB_ARRAY_JOBID(lsf_self->int_job_id),
LSB_ARRAY_IDX(lsf_self->int_job_id),
username?username:"******",
n_records ));
job_in_queue = n_records > 0;
if(!job_in_queue){
if(!(self->flags & FSD_JOB_CURRENT_SESSION)){
fsd_exc_raise_code( FSD_DRMAA_ERRNO_INVALID_JOB );
}else{/*handling missing job*/
self->on_missing(self);
}
}else{
job_info = lsb_readjobinfo( &more );
fsd_log_debug(( "lsb_readjobinfo(...) =%p: more=%d",
(void*)job_info, more ));
if( job_info == NULL )
fsd_exc_raise_lsf( "lsb_readjobinfo" );
lsf_self->read_job_info( self, job_info );
}
}
FINALLY
{
/* lsfdrmaa_free_job_info( job_info ); */
lsb_closejobinfo();
fsd_log_debug(( "lsb_closejobinfo()" ));
fsd_mutex_unlock( &self->session->drm_connection_mutex );
}
END_TRY
} while( !job_in_queue );
fsd_log_return(( "" ));
}
static const char*
fsd_template_get_attr( const fsd_template_t *self, const char *name )
{
const fsd_attribute_t *attr = NULL;
if( name == NULL )
fsd_exc_raise_code( FSD_ERRNO_INVALID_ARGUMENT );
attr = self->by_name( self, name );
if( attr == NULL || attr->is_vector )
fsd_exc_raise_fmt(
FSD_ERRNO_INVALID_ARGUMENT,
"invalid scalar attribute name: %s", name
);
return (const char*) self->attributes[ attr->code ];
}
void
fsd_drmaa_session_synchronize(
fsd_drmaa_session_t *self,
const char **input_job_ids, const struct timespec *timeout,
bool dispose
)
{
volatile bool wait_for_all = false;
char **volatile job_ids_buf = NULL;
const char **job_ids = NULL;
const char **i;
fsd_log_enter(( "(job_ids={...}, timeout=..., dispose=%d)",
(int)dispose ));
if( input_job_ids == NULL )
fsd_exc_raise_code( FSD_ERRNO_INVALID_ARGUMENT );
TRY
{
for( i = input_job_ids; *i != NULL; i++ )
if( !strcmp(*i, DRMAA_JOB_IDS_SESSION_ALL) )
wait_for_all = true;
if( wait_for_all )
{
job_ids_buf = self->get_submited_job_ids( self );
job_ids = (const char**)job_ids_buf;
}
else
job_ids = input_job_ids;
for( i = job_ids; *i != NULL; i++ )
TRY
{
self->wait_for_single_job( self, *i, timeout, NULL, NULL, dispose );
}
EXCEPT( FSD_DRMAA_ERRNO_INVALID_JOB )
{ /* job was ripped by another thread */ }
END_TRY
}
FINALLY
{
fsd_free_vector( job_ids_buf );
}
END_TRY
}
void
fsd_drmaa_session_destroy( fsd_drmaa_session_t *self )
{
bool already_destroying = false;
fsd_log_enter(( "" ));
fsd_mutex_lock( &self->mutex );
TRY
{
if( self->destroy_requested )
already_destroying = true;
else
{
self->destroy_requested = true;
fsd_cond_broadcast( &self->wait_condition );
}
}
FINALLY
{ fsd_mutex_unlock( &self->mutex ); }
END_TRY
if( already_destroying )
{ /* XXX: actually it can not happen in current implementation
when using DRMAA API */
self->release( self );
fsd_exc_raise_code( FSD_DRMAA_ERRNO_NO_ACTIVE_SESSION );
}
self->jobs->signal_all( self->jobs );
fsd_mutex_lock( &self->mutex );
TRY
{
while( self->ref_cnt > 1 )
fsd_cond_wait( &self->destroy_condition, &self->mutex );
fsd_log_debug(("started = %d run_flag = %d", self->wait_thread_started, self->wait_thread_run_flag ));
if( self->wait_thread_started )
self->stop_wait_thread( self );
}
FINALLY
{ fsd_mutex_unlock( &self->mutex ); }
END_TRY
self->destroy_nowait( self );
fsd_log_return(( "" ));
}
void
fsd_job_update_status( fsd_job_t *self )
{
fsd_exc_raise_code( FSD_ERRNO_NOT_IMPLEMENTED );
}
void
fsd_job_control( fsd_job_t *self, int action )
{
fsd_exc_raise_code( FSD_ERRNO_NOT_IMPLEMENTED );
}
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;
}
void
fsd_drmaa_session_wait_for_single_job(
fsd_drmaa_session_t *self,
const char *job_id, const struct timespec *timeout,
int *status, fsd_iter_t **rusage,
bool dispose
)
{
fsd_job_t *volatile job = NULL;
volatile bool locked = false;
fsd_log_enter(( "(%s)", job_id ));
TRY
{
job = self->get_job( self, job_id );
if( job == NULL )
fsd_exc_raise_fmt( FSD_DRMAA_ERRNO_INVALID_JOB,
"Job '%s' not found in DRMS queue", job_id );
job->update_status( job );
while( !self->destroy_requested && job->state < DRMAA_PS_DONE )
{
bool signaled = true;
fsd_log_debug(( "fsd_drmaa_session_wait_for_single_job: "
"waiting for %s to terminate", job_id ));
if( self->enable_wait_thread )
{
if( timeout )
signaled = fsd_cond_timedwait(
&job->status_cond, &job->mutex, timeout );
else
{
fsd_cond_wait( &job->status_cond, &job->mutex );
}
if( !signaled )
fsd_exc_raise_code( FSD_DRMAA_ERRNO_EXIT_TIMEOUT );
}
else
{
self->wait_for_job_status_change(
self, &job->status_cond, &job->mutex, timeout );
}
fsd_log_debug(( "fsd_drmaa_session_wait_for_single_job: woken up" ));
if( !self->enable_wait_thread )
job->update_status( job );
}
if( self->destroy_requested )
fsd_exc_raise_code( FSD_DRMAA_ERRNO_EXIT_TIMEOUT );
job->get_termination_status( job, status, rusage );
if( dispose )
{
job->release( job ); /*release mutex in order to ensure proper order of locking: first job_set mutex then job mutex */
locked = fsd_mutex_lock( &self->mutex );
job = self->get_job( self, job_id );
if (job != NULL)
{
self->jobs->remove( self->jobs, job );
job->flags |= FSD_JOB_DISPOSED;
}
else
{
fsd_log_error(("Some other thread has already reaped job %s", job_id ));
}
locked = fsd_mutex_unlock( &self->mutex );
}
}
FINALLY
{
if ( job )
job->release( job );
if ( locked )
fsd_mutex_unlock( &self->mutex );
}
END_TRY
fsd_log_return((""));
}