qlib.sh

Go to the documentation of this file.

#!/bin/zsh
#
#
# \author mdejong, bjjung
#
#--------------------------------------------------------------------------------------
#
#                   Utility script for batch queue functions.
#
#--------------------------------------------------------------------------------------


#
# Put command(s) in given queue; do not submit job.
#
# \param   1         queue name
# \param   2-N       command(s)
#
function put_queue()
{
    queue_name=$1
    shift
    
    echo -n "$*;" >> $queue_name
}


#
# Put command(s) in given queue and submit job.
#
# \param   1         queue name
# \param   2-N       command(s)
#
function puts_queue()
{
    queue_name=$1
    shift
    
    echo "$*" >> $queue_name
}


#
# Run queue.
#
# \param   1         queue name
# \param   2         queue size
# \param   3         sleep time [s]
#
function queue()
{
    queue_name=$1
    queue_size=$2
    sleep_time=$3

    if [[ -e $queue_name ]]; then

        if [[ -p $queue_name ]]; then
            fatal "Queue $queue_name in use."
        fi    
    else
        
        mkfifo $queue_name                                # create a new FIFO
    fi

    fd=7                                                  # file descriptor

    eval "exec $fd<>$queue_name"                          # attach file descriptor to FIFO

    while read job <& $fd; do                             # read job from file descriptor

        if [[ -n $job ]]; then
            
            if [[ $job = "exit" ]]; then
                break
            fi

            notice "submit $job" 
            eval exec $job &                              # submit job

            # wait for free slot
        
            while (( ${#jobstates} >= $queue_size )); do
                sleep $sleep_time
            done
        fi
    done
    
    rm -f $queue_name                                     # remove FIFO
}


# Function to configure jobs.\n
# Sets the environment variable EXEC_FILE, LOG_FILE as well as START_JOB and SUBMIT_JOB\n
# depending upon whether a new job should be set up or submitted.
#
# \param  groupsize       task group size
# \param  exec_filename   execution file name
#
configure_job()
{
    case $# in
        2) local groupsize=$2;
           local exec_filename=$1;;
        *) fatal "configure_job(): Invalid number of arguments."
    esac

    if [[ ! ${exec_filename} =~ '%' ]]; then
        fatal "configure_job(): Missing wildcard character in ${exec_filename}."
    fi
    
    if [[ -z $TASKID ]]; then  # Initialize task ID
        export TASKID=1
    fi

    if [[ -z $GROUPID ]]; then # Initialize task group ID
        export GROUPID=1
    fi

    local integer SUBTASKID=$(( TASKID % groupsize ))

    if   (( SUBTASKID == 1 || groupsize == 1 )); then # configure job start

        export EXEC_FILE=${exec_filename/\%/${GROUPID}}
        export LOG_FILE=${EXEC_FILE:r}.log      
        
        export START_JOB
        
        rm -f ${EXEC_FILE}
        
    elif (( SUBTASKID > 1 )); then
        unset  START_JOB
        unset  SUBMIT_JOB
    fi

    if (( SUBTASKID == 0 )); then # configure job submission
        
        export SUBMIT_JOB
        (( ++GROUPID ))
    fi

    (( ++TASKID ))
}


# Function to reset job configuration variables.
#
reset_job_config()
{
    unset TASKID
    unset GROUPID
    unset START_JOB
    unset SUMBIT_JOB
}


# Function to submit a job.
#
# \param  exec_file     job script
# \param  queue_name    batch queue name
# \param  scratchdir    scratch directory
# \param  dependencies  dependency PIDs
#
submit_job()
{
    local scratchdir=${TMPDIR:-/tmp}
    
    case $# in
        4) local dependencies=($4);&
        3) scratchdir=$3;&
        2) local queue_name=$2;&
        1) local exec_file=$1;;
        *) local exec_file=${argv[1]}
           local queue_name=${argv[2]}
           scratchdir=${argv[3]}
           local dependencies=(${argv[4,-2]})
    esac
    
    chmod +x ${exec_file}
    
    if (( ${+queue_name} )); then           

        if ( is_CCNikhef ); then

            local depstr="depend=afterok$(printf ':%s' ${dependencies[@]})"
            
            set_array JOBIDS \
                      ${JOBIDS[@]}                          \
                      ${$(qsub \
                              -N ${exec_file:t:r}.${USER}   \
                              ${dependencies:+-W ${depstr}} \
                              -q ${queue_name}              \
                              -o ${scratchdir}              \
                              -e ${scratchdir}              \
                              -j oe                         \
                              ${exec_file})%%.*}
        else

            if (( ${+dependencies} )); then

                local sleep_time=60
                
                for dep in ${dependencies[@]}; do
                
                    cat > ${scratchdir}/await_${dep}.sh <<EOF
#!/bin/zsh

while [[ -e /proc/${dep} ]]; do
    sleep ${sleep_time}
done

rm -f \$0
EOF
                    put_queue ${queue_name} ${scratchdir}/await_${dep}.sh
                done
            fi
            
            puts_queue ${queue_name} ${exec_file}.sh
        fi
        
    else
        
        zsh ${exec_file}
    fi
}