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 (( groupsize == 1 )); then

        export EXEC_FILE=${exec_filename/\%/${GROUPID}}
        export LOG_FILE=${EXEC_FILE:r}.log      
        
        export START_JOB
        export SUBMIT_JOB

        rm -f ${EXEC_FILE}
        
    elif (( SUBTASKID == 1 )); then # configure job start

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

        unset  START_JOB
        unset  SUBMIT_JOB
        
    elif (( SUBTASKID == 0 )); then # configure job submission

        unset  START_JOB
        export SUBMIT_JOB
        
        (( ++GROUPID ))
    fi

    (( ++TASKID ))

    export GROUPID
    export TASKID
}


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


# 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) 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]}
           dependencies=(${argv[4,-1]})
    esac

    chmod +x ${exec_file}
    
    if (( ${+queue_name} )); then           

        if ( is_CCNikhef ); then

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

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

                local sleep_time=60

                local depstr=$(printf '_%s' ${dependencies[@]})

                set_variable wait_script   ${scratchdir}/await${depstr}.sh              

                if [[ ! -f ${wait_script} ]]; then
                    
                    exec 9> ${wait_script}

                    cat <<EOF >&9
#!/bin/zsh
EOF
                    
                    for dep in ${dependencies[@]}; do
                        
                        cat <<EOF >&9

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

                    cat <<EOF >&9

N=\$(ps | grep "${wait_script:t:r}" | wc -l)

if (( N == 1 )); then
    rm -f ${wait_script}
fi
EOF

                    chmod u+x ${wait_script}

                    exec 9>&-
                fi

                sed -i "1a\\\n${wait_script}\n" ${exec_file}
            fi
            
            puts_queue ${queue_name} ${exec_file}
        fi
        
    else
        
        zsh ${exec_file}
    fi
}