Data Exercise 2.3: Using Stash for unique large input¶
In this exercise, we will run a multimedia program that converts and manipulates video files.
In particular, we want to convert large
.mov files to smaller (10-100s of MB)
Just like the Blast database in the previous exercise, these video
files are too large to send to jobs using HTCondor's default file transfer mechanism, so we'll be using the Stash tool
to send our data to jobs. This exercise should take 25-30 minutes.
A copy of the movie files for this exercise have been placed in
/public/osgvs21, so that they'll be available to our jobs when they run out on OSG.
- Log into
- Create a directory for this exercise named
stash-uniqueand change into it.
- We're going to need a list of these files later. Below is the final list of movie files. Because of the size, you do not need to download the files to your
/publicdirectory, and instead use the copies in the stash directory. For now, let's save a list of the videos to a file in this directory. Save it as
ducks.mov teaching.mov test_open_terminal.mov
We'll be using a multi-purpose media tool called
ffmpeg to convert video formats.
The basic command to convert a file looks like this:
[email protected] $ ./ffmpeg -i input.mov output.mp4
In order to resize our files, we're going to manually set the video bitrate and resize the frames, so that the resulting file is smaller.
[email protected] $ ./ffmpeg -i input.mp4 -b:v 400k -s 640x360 output.mp4
To get the
ffmpeg binary do the following:
We'll be downloading the
ffmpegpre-built static binary originally from this page: http://johnvansickle.com/ffmpeg/.
[email protected] $ wget http://stash.osgconnect.net/public/osgvs21/ffmpeg-release-64bit-static.tar.xz
Once the binary is downloaded, un-tar it, and then copy the main
ffmpegprogram into your current directory:
We want to write a script that runs on the worker node that uses
ffmpeg to convert a
.mov file to a smaller format.
Our script will need to:
- Copy that movie file from Stash to the job's current working directory (as in the previous exercise
- Run the appropriate
- Remove the original movie file so that it doesn't get transferred back to the submit server. This last step is particularly important, as otherwise you will have large files transferring into the submit server and filling up your local scratch directory space.
Create a file called
run_ffmpeg.sh, that does the steps described above.
Use the name of the smallest
.mov file in the
An example of that script is below:
#!/bin/bash module load stashcache stashcp /osgconnect/public/osgvs21/test_open_terminal.mov ./ ./ffmpeg -i test_open_terminal.mov -b:v 400k -s 640x360 test_open_terminal.mp4 rm test_open_terminal.mov
Ultimately we'll want to submit several jobs (one for each
.mov file), but to start with, we'll run one job to make
sure that everything works.
Create a submit file for this job, based on other submit files from the school (This file, for example.) Things to consider:
We'll be copying the video file into the job's working directory from StashCache, so make sure to request enough disk space for the input
movfile and the output
mp4file. If you're aren't sure how much to request, ask a helper.
Important Don't list the name of the
transfer_input_files. Our job will be interacting with the input
.movfiles solely from within the script we wrote above.
Note that we do need to transfer the
ffmpegprogram that we downloaded above.
transfer_input_files = ffmpeg
Add the same requirements as the previous exercise:
+WantsStashCache = true requirements = (OSGVO_OS_STRING == "RHEL 7") && (HAS_MODULES =?= true)
With everything in place, submit the job. Once it finishes, we should check to make sure everything ran as expected:
- Check the directory where you submitted the job. Did the output
- Also in the directory where you submitted the job - did the original
.movfile return here accidentally?
- Check file sizes. How big is the returned
.mp4file? How does that compare to the original
If your job successfully returned the converted
.mp4 file and did not transfer the
.mov file to the submit
server, and the
.mp4 file was appropriately scaled down, then we can go ahead and convert all of the files we uploaded
How to view your videos
Remember how we used the stash web server when we used it to distribute our blast database? You can use that web server to view the video files. Just copy the
.mp4 video into your
/public/<USERNAME> directory. The file will be available at
We wrote the name of the
.mov file into our
run_ffmpeg.sh executable script.
To submit a set of jobs for all of our
.mov files, what will we need to change in:
- The script?
- The submit file?
Once you've thought about it, check your reasoning against the instructions below.
Add an argument to your script¶
Look at your
run_ffmpeg.sh script. What values will change for every job?
The input file will change with every job - and don't forget that the output file will too! Let's make them both into arguments.
To add arguments to a bash script, we use the notation
$1 for the first argument (our input file) and
$2 for the
second argument (our output file name).
The final script should look like this:
#!/bin/bash module load stashcache stashcp /osgconnect/public/osgvs21/$1 ./ ./ffmpeg -i $1 -b:v 400k -s 640x360 $2 rm $1
Note that we use the input file name multiple times in our script, so we'll have to use
$1 multiple times as well.
Modify your submit file¶
We now need to tell each job what arguments to use. We will do this by adding an arguments line to our submit file. Because we'll only have the input file name, the "output" file name will be the input file name with the
mp4extension. That should look like this:
arguments = $(mov) $(mov).mp4
To set these arguments, we will use the
queue .. fromsyntax that we learned in the HTC Exercise 2.3. In our submit file, we can then change our queue statement to:
queue mov from movie_list.txt
Once you've made these changes, try submitting all the jobs!
If you wanted to set a different output file name, bitrate and/or size for each original movie, how could you modify:
- Your submit file
to do so?
Here's the changes you can make to the various files:
ducks.mov ducks.mp4 500k 1280x720 teaching.mov teaching.mp4 400k 320x180 test_open_terminal.mov terminal.mp4 600k 640x360
arguments = $(mov) $(mp4) $(bitrate) $(size) queue mov,mp4,bitrate,size from movie_list.txt
1 2 3 4 5 6
#!/bin/bash module load stashcache stashcp /osgconnect/public/osgvsp20/$1 ./ ./ffmpeg -i $1 -b:v $3 -s $4 $2 rm $1