Examples – Using Job Dependencies Versus Array Task Dependencies to Complete Array Jobs

The following example illustrates the difference between the job dependency facility and the task array dependency facility:

• In the following example, array task B is dependent on array task A:

  $ qsub -t 1-3 A
  $ qsub -hold_jid A -t 1-3 B
  

  All the sub-tasks in job B will wait for all sub-tasks 1,2 and 3 in A to finish before starting the tasks in job B. The tasks will be executed in the following approximate order: A.1, A.2, A.3, B.1, B.2, B.3, as shown below:

  | A.1 |     | B.1 |
  | A.2 | --> | B.2 |
  | A.3 |     | B.3 |
  

• In the following example, each sub-task in array job B is dependent on each corresponding sub-task in job A in a one-to-one mapping:

  $ qsub -t 1-3 A
  $ qsub -hold_jid_ad A -t 1-3 B
  

  Sub-task B.1 will only start when A.1 completes. B.2 will only start once A.2 completes, etc. On a single machine renderfarm, the tasks thus could be executed in the following approximate order: A.1, B.1, A.2, B.2, A.3, B.3, as shown below:

  | A.1 | --> | B.1 |
  | A.2 | --> | B.2 |
  | A.3 | --> | B.3 |
  

  It should only be able to specify the option if we are submitting an array job, it is dependent on another array job, and that array job has the same number of sub-tasks.

Examples – Using Array Task Dependencies to Chunk Tasks

When using 3D rendering applications, it is often more efficient to render several frames at once on the same CPU instead of distributing the frames across several machines. The generation of several frames at once we will refer to as chunking.

When using the task dependency facility, the array task must have the same range of sub-tasks as its dependent array task, otherwise the job will be rejected at submit time.

The following examples illustrate chunking:

• Array task B is dependent on array task A, which has a step size of 2:

  $ qsub -t 1-6:2 A
  $ qsub -hold_jid_ad A -t 1-6 B
  

  In the results shown below, it is assumed that array task A is chunking, which means that B.1 and B.2 are dependent on A.1, B.3 and B.4 are dependent on A.3, and so on. If job A.1 didn't render frame 2, then job B.2 would fail:

  | A.1 | --> | B.1 |
  |     | --> | B.2 |
  | A.3 | --> | B.3 |
  |     | --> | B.4 |
  | A.5 | --> | B.5 |
  |     | --> | B.6 |
  

• Array task B is dependent on array task A, which has a step size of 1:

  $ qsub -t 1-6 A
  $ qsub -hold_jid_ad A -t 1-6:2 B
  

  In this example shown below, array task B is chunking, which means that job B.1 is dependent on job A.1 and job A.2, job B.3 is dependent on job A.3 and job A.4, and so on. It is reasonable to always assume that array task B is chunking because otherwise A.2, A.4, and A.6 would be needlessly run and the result would never be used:

  | A.1 | --> | B.1 |
  | A.2 | --> |     |
  | A.3 | --> | B.3 |
  | A.4 | --> |     |
  | A.5 | --> | B.5 |
  | A.6 | --> |     |
  

• Array task A has a step size of 3 and array task B has a step size of 2. The tasks are dependent on each other:

  $ qsub -t 1-6:3 A
  $ qsub -hold_jid_ad A -t 1-6:2 B
  

  In this example shown below, both array task A and array task B are chunking. So, job B.1 is dependent on job A.1, job B.3 is dependent on job A.1 and job A.4, and job B.5 is dependent on job A.4. When the hold array dependency option -hold_jid_ad is specified and the step sizes of the array job and the dependent array job are different, we always assume that both are chunking:

  | A.1 | --> | B.1 |
  |     | --> |     |
  |     | --> | B.3 |
  | A.4 | --> |     |
  |     | --> | B.5 |
  |     | --> |     |