Job Submission

• 1 Job Submission
  • 1.1 Standard Job Submission
  • 1.2 Common Job Submission Options
  • 1.3 Draft and Shotgun Submission Options
  • 1.4 Frame List Formatting Options
  • 1.5 Submitting Arbitrary Command Line Jobs To Deadline
  • 1.6 Creating Submission Files And Submitting Them To Deadline
    • 1.6.1 The Job Info File
    • 1.6.2 The Plug-in Info File

Standard Job Submission

The easiest and most common way to submit render jobs to Deadline is via our many submission scripts which are written for each rendering application that Deadline supports. After you have submitted your job to Deadline, you can Monitor Its Progress using the Deadline Monitor.

Integrated Submission Scripts

Where possible, we have created integrated submission scripts that allow you to submit jobs directly from the application you're working with. See the Deadline Plug-ins documentation for more information on how to set up the integrated submission scripts (where applicable) and submit jobs for specific applications.

Monitor Submission Scripts

In cases where an application doesn't have an integrated submission script, you can submit the jobs from the Submit menu in the Deadline Monitor. Note that applications that have integrated submission scripts also have Monitor scripts here, but in most cases there are less options to choose from. This is because the integrated submission scripts use the application's native scripting language to pull additional information from the file being submitted. See the Deadline Plug-ins documentation for more information on how submit jobs for specific applications.

You can also create your own submission scripts for the Deadline Monitor. Check out the Monitor Scripting documentation for more details.

Common Job Submission Options

There are many job options that can be specified on submission. A lot of these options are general job properties that aren't specific to the application you're rendering with. Some of these options are described below. There are also many other options that are specific to the application that you're rendering with. These are covered in each application's plug-in guide, which can be found in the Deadline Plug-ins documentation.

Job Name

The name of your job. This is optional, and if left blank, it will default to "Untitled".

Comment

A simple description of your job. This is optional and can be left blank.

Department

The department you belong to. This is optional and can be left blank.

Pool and Group

The pool and group that the job belongs to. See the Job Scheduling documentation for more information on how these options affect job scheduling.

Priority

A job can have a numeric priority ranging from 0 to 100, where 0 is the lowest priority and 100 is the highest priority. See the Job Scheduling documentation for more information on how this option affects job scheduling.

Task Timeout and Auto Task Timeout

The number of minutes a slave has to render a task for this job before it requeues it. Specify 0 for no limit. If the Auto Task Timeout is properly configured in the Repository Options, then enabling the Auto Task Timeout option will allow a task timeout to be automatically calculated based on the render times of previous frames for the job.

Concurrent Tasks and Limiting Tasks To A Slave's Task Limit

The number of tasks that can render concurrently on a single slave. This is useful if the rendering application only uses one thread to render and your slaves have multiple CPUs. Caution should be used when using this feature though if your renders require a large amount of RAM.

If you limit the tasks to a slave's task limit, then by default, the slave won't dequeue more tasks then it has CPUs. This task limit can be overridden for individual slaves by an administrator. See the Slave Settings documentation for more information.

Machine Limit and Machine Whitelists/Blacklists

Use the Machine Limit to specify the maximum number of machines that can render your job at one time. Specify 0 for no limit. You can also force the job to render on specific machines by using a whitelist, or you can avoid specific machines by using a blacklist. See the Limit Documentation for more information.

Limits

The limits that your job must adhere to. See the Limit Documentation for more information.

Dependencies

Specify existing jobs that this job will be dependent on. This job will not start until the specified dependencies finish rendering.

On Job Complete;

If desired, you can automatically archive or delete the job when it completes.

Submit Job As Suspended

If enabled, the job will submit in the suspended state. This is useful if you don't want the job to start rendering right away. Just resume it from the Monitor when you want it to render.

Frame List

The list of frames to render. See the Frame List Formatting Options below for valid frame lists.

Frames Per Task;

Also known as Chunk Size. This is the number of frames that will be rendered at a time for each job task. Increasing the Frames Per Task can help alleviate some of the inherited overhead that comes with network rendering, but if your frames take longer than a couple of minutes to render, it is recommended that you leave the Frames Per Task at 1.

Submit Project/Scene File With Job

If this option is enabled, the scene/project file you want to render will be submitted with the job, and then copied locally to the slave machine during rendering. The benefit to this is that you have a copy of the file in the state that it was in when it was submitted. However, if your scene/project file uses relative asset paths, enabling this option can cause the render to fail when the asset paths can't be resolved.

If this option is disabled, the file needs to be in a shared location so that the slave machines can find it when they go to render it directly. Leaving this option disabled is required if the file has references (footage, textures, caches, etc) that exist in a relative location. Note though that if you modify the original file, it will affect the render job.

Draft and Shotgun Submission Options

The majority of the submission scripts that ship with Deadline have options to connect to Shotgun, and/or use Draft to perform post-rendering compositing operations. Setting the Shotgun and Draft job options is essentially the same in every submission script, and more information can be found in their respective documentation:

• Draft Documentation
• Shotgun Documentation

Frame List Formatting Options

During job submission, you usually have the option to specify the frame list you want to render, which often involves manually typing the frame list into a text box. In this case, you can make use of Deadline's frame list formatting options.

Specifying Individual Frames or a Sequence

You can specify a single frame just by typing in the frame number:

5

You can specify individual frames be separating each frame with a comma or a space:

5,10,15,20
5 10 15 20

You can specify a frame range by separating the start and end frame with a dash:

1-100

Specifying a Sequence with a Step Frame

You can specify a step frame for a sequence using x, step, by, or every:

1-100x5
1-100step5
1-100by5
1-100every5

Each of these examples will render every 5th frame between 1 and 100 (1, 6, 11, 16, etc).

Advanced Frame Lists

Deadline never repeats individual frames when creating tasks for a job, which allows you to get creative with your frame lists without worrying if you're specifying a frame more than once.

To render frames 5, 18, and then from 28 to 100, you can specify one of the following:

5,18,28-100
5 18 28-100

To render every 5th frame between 1 to 100, then fill in the rest, you can specify one of the following:

1-100x5,1-100
1-100x5 1-100

To render every 10th frame between 1 to 100, then every 5th frame, then every 2nd frame, then fill in the rest, you can specify one of the following:

1-100x10,1-100x5,1-100x2,1-100
1-100x10 1-100x5 1-100x2 1-100

Submitting Arbitrary Command Line Jobs To Deadline

To manually submit arbitrary command line jobs to Deadline, you can use the -SubmitCommandLineJob option with the Deadline Command application. The key parameters that you need to specify are:

• -executable: The executable we wish to use.
• -arguments: The arguments we wish to pass to the exectutable. In the arguments string, there are a few key words that will be replaced with the appropriate text when rendering the job:
  • <STARTFRAME> will be replaced with the current start frame for each task.
  • <ENDFRAME> will be replaced by the current end frame for each task.
  • <STARTFRAME%#> will be replaced with the current start frame for each task, and will be padded with 0's to match the length specified for #. For example, <STARTFRAME%4> will ensure a start frame padding of 4.
  • <ENDFRAME%#> will be replaced by the current end frame for each task, and will be padded with 0's to match the length specified for #. For example, <ENDFRAME%6> will ensure an end frame padding of 6.
  • <QUOTE> will be replaced with an actual quote character (").
• -frames: The frames we wish to render.

The following parameters can also be included, but are optional:

• -startupdirectory: The directory that the command line will start up in.
• -chunksize: The number of frames per task (defaults to 1).
• -pool: The pool we wish to submit to (defaults to none).
• -group: The group we wish to submit to (defaults to none).
• -priority: The job's priority (defaults to 50).
• -name: The job's name (defaults to "Untitled").
• -department: The job's department (defaults to "").
• -initialstatus: Specify "Active" or "Suspended" (defaults to "Active").
• -prop: Specify additional job properties in the form KEY=VALUE, where KEY is any of the property names that can be specified in the Job Info File.

For example, say we want to submit a job that uses 3dsmaxcmd.exe to render frames in the scene file "\\shared\path\scene.max". We want to render frames 1 to 10, and we want an image resolution of 480x320. The command line to do this without using Deadline would look like:

3dsmaxcmd.exe
 -start:1
 -end:10
 -width:480
 -height:320
 "\\shared\path\scene.max"

For the Deadline job, we want a task chunk size of 2, we want to submit to the 3dsmax group, we want a priority of 50, and we want a machine limit of 5. Finally, we want to call the job "3dsmax command line job". The command line to submit this job to Deadline would look like (note that we've split the -arguments line across two lines):

DeadlineCommand.exe
 -SubmitCommandLineJob
 -executable "c:\Program Files\Autodesk\3dsmax8\3dsmaxcmd.exe"
 -arguments "-start:<STARTFRAME> -end:<ENDFRAME> -width:480 -height:320
 <QUOTE>\\shared\path\scene.max<QUOTE>"
 -frames 1-10
 -chunksize 2
 -group 3dsmax
 -priority 50
 -name "3dsmax command line job"
 -prop MachineLimit=5

Creating Submission Files And Submitting Them To Deadline

This is the method that our submission scripts use to submit jobs to Deadline. This method is far more flexible, but requires more work to setup the job. It also uses Deadline Command to submit the job.

Before the job can be submitted though, a Job Info File must be created. Depending on the plug-in you are submitting the job to, a Plug-in Info File may also be required. Once these files are created, you can submit the job using the command line:

    DeadlineCommand.exe [Job Info File] [Plug-in Info File] [Scene File] ...

For all files being passed to the Deadline Command application, you should specify their complete path. If you have other files that you wish to include with the submission other than the scene file, you can specify them after the [Scene File] parameter. If a Plug-in Info File is not required by the plug-in you are submitting the job to, you can omit the [Plug-in Info File] parameter.

The Job Info File

The Job Info File is a plain text file that uses Key/Value pairs (key=value) to define all the generic job options that Deadline uses to render the job. A couple options are required, but most are optional. All jobs can use these options, regardless of the plug-in that they use. Some examples have been provided below.

Required Options

• Plugin=<plugin name> : Specifies the plugin to use. Must match an existing plugin in the repository.

• Frames=<1,2,3-10,20> : Specifies the frame range of the render job.

General Options (Optional)

• Name=<job name> : Specifies the name of the job (default = Untitled).

• UserName=<username> : Specifies the job's user (default = current user).

• MachineName=<machineName> : Specifies the machine the job was submitted from (default = current machine).

• Department=<department name> : Specifies the department that the job belongs to. This is simply a way to group jobs together, and does not affect rendering in any way (default = blank).

• Comment=<comment> : Specifies a comment for the job (default = blank).

• Group=<groupName> : Specifies the group that job is being submitted to (default = none).

• Pool=<poolName> : Specifies the pool that job is being submitted to (default = none).

• Priority=<0-100> : Specifies the priority of a job with 0 being the lowest and 100 being the highest (default = 50).

• ChunkSize=<1 or greater> : Specifies how many frames to render per task (default = 1).

• ForceReloadPlugin=<true/false> : Specifies whether or not to reload the plugin between subsequent frames of a job (default = false). This deals with memory leaks or applications that do not unload all job aspects properly.

• SynchronizeAllAuxiliaryFiles=<true/false> : If enabled, all job files (as opposed to just the job info and plugin info files) will be synchronized by the Slave between tasks for this job (default = false). Note that this can add significant network overhead, and should only be used if you plan on manually editing any of the files that are being submitted with the job.

• InitialStatus=<Active/Suspended> : Specifies what status the job should be in immediately after submission (default = Active).

• LimitGroups=<limitGroup,limitGroup,limitGroup> : Specifies the limit groups that this job is a member of (default = blank).

• MachineLimit=<0 or greater> : Specifies the maximum number of machines this job can be rendered on at the same time (default = 0, which means unlimited).

• MachineLimitProgress=<0.1 or greater> : If set, the slave rendering the job will give up its current machine limit lock when the current task reaches the specified progress. If negative, this feature is disabled (default = -1.0). The usefulness of this feature is directly related to the progress reporting capabilities of the individual plugins.

• Whitelist=<slaveName,slaveName,slaveName> : Specifies which slaves are on the job's whitelist (default = blank). If both a whitelist and a blacklist are specified, only the whitelist is used.

• Blacklist=<slaveName,slaveName,slaveName> : Specifies which slaves are on the job's blacklist (default = blank). If both a whitelist and a blacklist are specified, only the whitelist is used.

• DeleteOnComplete=<true/false> : Specifies whether or not the job should be automatically deleted after it completes (default = false).

• ArchiveOnComplete=<true/false> : Specifies whether or not the job should be automatically archived after it completes (default = false).

• OnJobComplete=<Nothing/Delete/Archive> : Specifies what should happen to a job after it completes (default = Nothing).

• ConcurrentTasks=<1-16> : Specifies the maximum number of tasks that a slave can render at a time (default = 1). This is useful for script plugins that support multithreading.

• LimitTasksToNumberOfCpus=<true/false> : If ConcurrentTasks is greater than 1, setting this to true will ensure that a slave will not dequeue more tasks than it has processors (default = true).

• Sequential=<true/false> : Sequental rendering forces a slave to render the tasks of a job in order. If an earlier task is ever requeued, the slave won't go back to that task until it has finished the remaining tasks in order (default = false).

• Interruptible=<true/false> : Specifies if tasks for a job can be interrupted by a higher priority job during rendering (default = false).

• SuppressEvents=<true/false> : If true, the job will not trigger any event plugins while in the queue (default = false).

• NetworkRoot=<repositoryUNCPath> : Specifies the repository that the job will be submitted to. This is required if you are using more than one repository (default = current default repository for the machine from which submission is occurring).

Failure Detection Options (Optional)

• OverrideJobFailureDetection=<true/false> : If true, the job will ignore the global Job Failure Detection settings and instead use its own (default = false).

• FailureDetectionJobErrors=<0 or greater> : If OverrideJobFailureDetection is true, this sets the number of errors before the job fails. If set to 0, job failure detection will be disabled.

• OverrideTaskFailureDetection=<true/false> : If true, the job will ignore the global Task Failure Detection settings and instead use its own (default = false).

• FailureDetectionTaskErrors=<0 or greater> : If OverrideTaskFailureDetection is true, this sets the number of errors before a task for the job fails. If set to 0, task failure detection will be disabled.

• IgnoreBadJobDetection<true/false> : If true, slaves will never mark the job as bad for themselves. This means that they will continue to make attempts at jobs that often report errors until the job is complete, or until it fails (default = false).

• SendJobErrorWarning=<true/false> : If the job should send warning notifications when it reaches a certain number of errors (default = false).

Timeout Options (Optional)

• MinRenderTimeSeconds=<0 or greater> : Specifies the minimum time, in seconds, a slave should render a task for, otherwise an error will be reported (default = 0, which means no minimum).

• MinRenderTimeMinutes=<0 or greater> : Specifies the minimum time, in minutes, a slave should render a task for, otherwise an error will be reported (default = 0, which means no minimum).

• TaskTimeoutSeconds=<0 or greater> : Specifies the time, in seconds, a slave has to render a task before it times out (default = 0, which means unlimited).

• TaskTimeoutMinutes=<0 or greater> : Specifies the time, in minutes, a slave has to render a task before it times out (default = 0, which means unlimited).

• OnTaskTimeout=<Error/Notify/Both> : Specifies what should occur if a task times out (default = Error).

• EnableAutoTimeout=<true/false> : If true, a slave will automatically figure out if it has been rendering too long based on some Repository Configuration settings and the render times of previously completed tasks (default = false).

• EnableTimeoutsForScriptTasks=<true/false> : If true, then the timeouts for this job will also affect its pre/post job scripts, if any are defined (default = false).

Dependency Options (Optional)

• JobDependencies=<jobID,jobID,jobID> : Specifies what jobs must finish before this job will resume (default = blank). These dependency jobs must be identified using their unique job ID, which is outputted after the job is submitted, and can be found in the Monitor in the "Job ID" column.

• JobDependencyPercentage=<-1, or 0 to 100> : If between 0 and 100, this job will resume when all of its job dependencies have completed the specified percentage number of tasks. If -1, this feature will be disabled (default = -1).

• IsFrameDependent=<true/false> : Specifies whether or not the job is frame dependent (default = false).

• ResumeOnCompleteDependencies=<true/false> : Specifies whether or not the dependent job should resume when its dependencies are complete (default = true).

• ResumeOnDeletedDependencies=<true/false> : Specifies whether or not the dependent job should resume when its dependencies have been deleted (default = false).

• ResumeOnFailedDependencies=<true/false> : Specifies whether or not the dependent job should resume when its dependencies have failed (default = false).

Scheduling Options (Optional)

• ScheduledType=<None/Once/Daily> : Specifies whether or not you want to schedule the job (default = None).

• ScheduledStartDateTime=<dd/MM/yyyy HH:mm> : The date/time at which the job will run. The start date/time must match the specified format. Here's an explanation:
  • dd: The day of the month. Single-digit days must have a leading zero.
  • MM: The numeric month. Single-digit months must have a leading zero.
  • yyyy: The year in four digits, including the century.
  • HH: The hour in a 24-hour clock. Single-digit hours must have a leading zero.
  • mm: The minute. Single-digit minutes must have a leading zero.

• ScheduledDays=<day interval> : If scheduling a Daily job, this is the day interval for when the job runs (default = 1).

Output Options (Optional)

• OutputFilename#=<fileName> : Specifies the output image filenames for each frame (default = blank). This allows for Deadline to display the "View Output Image" context menu option in the task list. The filename should have '#' or '?' in the location where the frame numbers should be. If the filename is a full path, then the OutputDirectory# option is not needed. This option is numbered, starting with 0, to handle multiple output file names per frame (as is the case with Digital Fusion flows). The maximum allowed in six.

• OutputDirectory#=<directoryName> : Specifies the output image directory for the job (default = blank). This allows for Deadline to display the "Explore Output" context menu option in the job list. This option is numbered, starting with 0, to handle multiple output directories per frame. The maximum allowed in six.

Notification Options (Optional)

• NotificationTargets=<username,username,username> : A list of users, separated by commas, who should be notified when the job is completed (default = blank).

• ClearNotificationTargets=<true/false> : If enabled, all of the job's notification targets will be removed (default = false).

• NotificationEmails=<email,email,email> : A list of additional email addresses, separated by commas, to send job notifications to (default = blank).

• OverrideNotificationMethod=<true/false> : If the job user's notification method should be ignored (default = false).

• EmailNotification=<true/false> : If overriding the job user's notification method, whether to use email notification (default = false).

• GrowlNotification=<true/false> : If overriding the job user's notification method, whether to use Growl notification (default = false).

• NetsendNotification=<true/false> : If overriding the job user's notification method, whether to use netsend notification (default = false).

• NotificationNote=<note> : A note to append to the notification email sent out when the job is complete (default = blank). Separate multiple lines with [EOL], for example:

This is a line[EOL]This is another line[EOL]This is the last line

Script Options (Optional)

• PreJobScript=<path to script> : Specifies a full path to a python script to execute when the job initially starts rendering (default = blank).

• PostJobScript=<path to script> : Specifies a full path to a python script to execute when the job completes (default = blank).

• PreTaskScript=<path to script> : Specifies a full path to a python script to execute before each task starts rendering (default = blank).

• PostTaskScript=<path to script> : Specifies a full path to a python script to execute after each task completes (default = blank).

Tile Job Options (Optional)

• TileJob=<true/false> : If this job is a tile job (default = false).

• TileJobFrame=<frameNumber> : The frame that the tile job is rendering (default = 0).

• TileJobTilesInX=<xCount> : The number of tiles in X for a tile job (default = 0).

• TileJobTilesInY=<yCount> : The number of tiles in Y for a tile job (default = 0).

Extra Info Options (Optional)

These are extra arbitrary properties that have corresponding columns in the Deadline Monitor that can be sorted on. There are a total of 10 Extra Info properties that can be specified.

• ExtraInfo0=<arbitrary value>
• ExtraInfo1=<arbitrary value>
• ExtraInfo2=<arbitrary value>
• ExtraInfo3=<arbitrary value>
• ExtraInfo4=<arbitrary value>
• ExtraInfo5=<arbitrary value>
• ExtraInfo6=<arbitrary value>
• ExtraInfo7=<arbitrary value>
• ExtraInfo8=<arbitrary value>
• ExtraInfo9=<arbitrary value>

These are additional arbitrary properties. There is no limit on the number that are specified, but they do not have corresponding columns in the Deadline Monitor.

• ExtraInfoKeyValue0=<key=value>
• ExtraInfoKeyValue1=<key=value>
• ExtraInfoKeyValue2=<key=value>
• ExtraInfoKeyValue3=<key=value>
• ...

Job Info File Examples

 Plugin=3dsmax
 ForceReloadPlugin=false
 Frames=0-400
 Priority=50
 Pool=3dsmax
 Name=IslandWaveScene_lighted01
 Comment=Testing
 OutputDirectory0=\\fileserver\Renders\OutputFolder\
 OutputFilename0=islandWaveBreak_Std####.png

 Plugin=Lightwave
 Frames=1-10,21-30
 ChunkSize=10
 Priority=99
 Pool=LightwavePool
 Group=NiceShot
 Name=Lightwave Test
 OutputFilename0=\\fileserver\Renders\OutputFolder\test####.tif
 DeleteOnComplete=true
 MachineLimit=5
 SlaveTimeout=3600

 Plugin=DFusion
 Frames=1-100
 Priority=50
 Group=DFusion
 Name=DFusion Dependency Test
 OutputFilename0=\\fileserver\Renders\OutputFolder\dfusion_test####.tif
 JobDependencies=t_050_o_2D2E1BF9,m_099_o_2BA5022A
 InitialStatus=Suspended
 LimitGroups=DFRNode
 ExtraInfo0=Regression Testing
 ExtraInfoKeyValue0=TestID=344
 ExtraInfoKeyValue1=DeveloperID=12

The Plug-in Info File

The Plug-in Info File is a plain text file that uses Key/Value pairs (key=value) to define the plug-in specific options that are used by the individual plug-ins to render the job. Often, these options are used to build up the command line arguments that are to be passed on to the rendering application.

The plug-ins read in the settings from the Plug-in Info File using the script functions GetPluginInfoEntry(...) and GetPluginInfoEntryWithDefault(...), which are discussed in more detail in the Plug-in Scripting documentation.