TITLE: Prepare and run test on available dataset
AUTHORS: Stepan Orlov, Alexey Zhuravlev, Егор Усик, Alexey Kuzin

[DESCRIPTION]
<div class = "text-blocks"><div class = "text-block">This protocol shows how to perform tests whose results are presented in the manuscript dedicated to the ReVisE open source visualization system. The system implements interactive visualization of large datasets hosted on a remote server or a supercomputer. The protocol also refers to another protocol that describes how to build and install the ReVisE system; that step should be taken if ReVisE has not been built yet on the server machine. The entire process, as described in the protocols, has been tested on Ubuntu 18.04 and Ubuntu 20.04 Linux distributions.</div></div>

[STEPS]
?. [Prepare to measure ReVisE visualization performance]
Download and build the ReVisE system if it is not built.
{"blocks":[{"key":"8vgnr","text":"Current protocol is intended to show how to build visualization system which is called ReVisE. Such system is aimed to provide interactive visualization of large datasets hosted on a remote server or a supercomputer. The installation is described for OS Ubuntu.","type":"unstyled","depth":0,"inlineStyleRanges":[],"entityRanges":[],"data":[]}],"entityMap":[]}
Skip this step if ReVisE has already been built on the target machine.
?. Set REVISE_TOTAL_GPUS environment variable to the number of NVIDIA GPUs available on the machine (e.g. use nvidia-smi to figure out the number of GPUs)REVISE_TOTAL_GPUS=1
?. Set the REVISE_DATASET_TYPE environment variable containing the type identifier of the dataset REVISE_DATASET_TYPE=imm-g
?. Go to the directory where the dataset is to be downloaded and preprocessed. There must be at least 60 GB of free space.cd
?. Prepare custom ReVisE Web server configuration files for testing. revise_webdata.js install test_datasets.json revise_hw_config.js install test_hw.json revise_hw_config.js set nodes 1 revise_hw_config.js set assemble_threads_per_node $REVISE_ASM_THREADS revise_hw_config.js set measure_time true
?. Download and extract ReVisE preprocessor input for the dataset.curl https://ftp.mpksoft.ru/revise_datasets/$REVISE_DATASET/${REVISE_DATASET}_revise_input.tar.gz --output ${REVISE_DATASET}_revise_input.tar.gztar -zxf ${REVISE_DATASET}_revise_input.tar.gz
?. Download the dataset source data (mesh and field snapshots at 13 time layers).curl https://ftp.mpksoft.ru/revise_datasets/$REVISE_DATASET/${REVISE_DATASET}_src.tar.gz --output ${REVISE_DATASET}_src.tar.gz
file size is about 26 GB, download will likely take several hours curl
?. Preprocess the dataset. This will result in the generation of ReVisE dataset for visualization../prep_${REVISE_DATASET}_revise.sh
This step takes about 1.5 hours on a desktop system with Intel i7-8700 CPU @3.20GHz (6 cores), 16 GB RAM.If you have more RAM, you might want to edit the script (see comments in it).
?. Add ReVisE dataset to the list of problems available to the ReVisE Web serverrevise_webdata.js add ${REVISE_DATASET}_revise.$REVISE_DATASET_TYPE $REVISE_DATASET
For animated datasets, we follow directory name by a suffix, which is its type
?. Set the REVISE_GPUS environment variable to the number of GPUs to use in the test.REVISE_GPUS=1
?. Set REVISE_WORKERS environment variable to the number of rendering worker threads to use in the test.REVISE_WORKERS=1
?. Specify hardware configuration to use by ReVisE. revise_hw_config.js set gpus_per_node $REVISE_GPUS revise_hw_config.js set render_threads_per_node $REVISE_WORKERS
?. Create directory for performance log files. LOGDIR=log/$REVISE_MACHINE/$REVISE_DATASET mkdir -p $LOGDIR
?. Start ReVisE Web server.revise_web.sh
When the Web server is started for the first time, the script downloads and installsnecessary dependencies and builds two ReVisE modules that interoperate with node.js.This process takes a few seconds. When the server starts, it displays the message"Starting web server"
?. Prepare Web browser for measuring ReVisE performance.
?. Open Web browser (we use Chrome and Firefox, other browser should work too).
?. type localhost:3000 in the address bar and press Enter.
?. Maximize browser window.
?. Select problem: choose dataset name
?. Select field: rho_nu
?. Reset data; wait a few seconds
?. Set fovY to 11;Fields are shown as relative values;Time interval, ms = 1
?. Select Visualization mode: MIP
?. Move to the left the slider below the visualization mode selector.
?. Stop web server: go to terminal where the web server is running and press Ctrl+C.
?. Go to the Web browser and refresh the window; return to the terminal again.
?. Start ReVisE Web server again.revise_web.sh
?. Colormap settings: Ok
?. Stop web server; refresh browser window; return to terminal.
?. Remove timestamp logrm $REVISE_ROOT_DIR/src/webserver/VsRendererDrawTimestamps.log
?. Measure ReVisE performance for specific hardware configuration.
?. Measure ReVisE performance for more hardware configurations.At this point, repeat sequence of steps 17, 18, 19, 23 multiple times, each time setting different values of REVISE_GPUS and REVISE_WORKERS. For example, on a DGX-1 machine that has 8 GPUs, we would take values from the table below:111212314422524628744848941610881181612832
111212314422524628744848941610881181612832
Note: At this step, the experiment No. 1, with 1 worker thread and 1 GPU, is already done!
?. Process measurement results with the special toolrevise_process_render_perf_logs.sh $LOGDIR
?. Print resultscat $LOGDIR/*/task_avg_duration.tsvTODO: Prettify results
?. Start ReVisE Web server from Linux terminal.revise_web.sh
?. Refresh browser window.
?. Wait till "Frame level: 3" is reported in the lower left corner of the window. First time it might take about 20 s, in the minimal HW configuration
?. Press button of setting the current camera position corresponding to XY-plane 10 times, each time waiting till "Frame level: 3" is reported
?. Stop web server; refresh browser window; return to terminal.
?. Move the timestamp log file to the log directory:mv $REVISE_ROOT_DIR/src/webserver/VsRendererDrawTimestamps.log $LOGDIR/VsRendererDrawTimestamps-$REVISE_GPUS-$REVISE_WORKERS-$REVISE_ASM_THREADS.log
?. Open Settings dialog
?. Click the Ok button
?. [Prepare to measure ReVisE visualization performance]
Open Linux terminal.If ReVisE is to be run on a remote machine, connect to the machine using ssh. In that case, make sure to use local forwarding since the ports 1234 and 3000 are needed for interacting with the ReVisE web server.ssh -L 1234:localhost:1234 -L 3000:localhost:3000 username@hostname
?. Compute sufficient number of assemble threadsREVISE_ASM_THREADS=$((2*$REVISE_TOTAL_GPUS))
?. Download initial dataset with the
?. [Prepare to measure ReVisE visualization performance]
Go to the directory where datasets are to be installed. Make sure to choose a location where sufficient free disk space is available (see table below).cd Further steps can be performed either manually, using the detailed step-by-step instruction, or automatically with an interactive script. In the former case, it is easy to locate the problem if a command fails. In the latter case, it is convenient to have most of the work done by a single script.
The table below provides details about datasets, such as download size, preprocessed dataset size, estimated preprocessing time, and memory (RAM) required for the preprocessing and visualization. Notice that the required RAM size is rounded to the nearest power of two.Also notice that the downloading time is highly dependent on Internet connection speed, and maximum download speed available on our data hosting is 100 Mbit/s.cascade16600027.930.4hump1657018.370mwave128230005.8sphere1M81300.015
To measure the performance, it is required to run a Web browser on the client machine. We run Web browser on a display with FullHD resolution (1920 x 1080 pixels). For other resolutions, test results might differ, as the resolution has major influence on rendering times.
?. [Download and preprocess dataset; measure visualization performance]
Perform measurements. This can be done with the script:revise_measure_perf.sh The user is then expected to take some actions according to messages printed by the script in Linux terminal. Upon successfull completion of the script, the results of performance measurement are printed.Substeps below are not intended to be run by the user. Rather those are remarks explaining what the script does and how.
If the download of the source dataset is interrupted due to an unstable internet connection, just repeat this step once again. The download will continue.
On rare occasion, the preprocessing may fail. In this case, the file $REVISE_DATASET/prepare.log will contain the word ERROR. If that happens, execute the following commands:find  -name "*.s3dmm*" -exec rm {} \;rm /revise_readywhere  is the dataset name. Then repeat this step once again (no downloading will be repeated).
?. [Download and preprocess dataset]
Set the REVISE_DATASET environment variable.REVISE_DATASET=
At the moment,  may be one of the following:cascadehumpmwavesphere1M
?. [Download and preprocess dataset; measure visualization performance]
Set up environment if necessary.source $( dirname "${BASH_SOURCE[0]}" )/env.sh
?. [Download and preprocess dataset; measure visualization performance]
Guess and read the total number of GPUs; also guess machine name.if [ ! -z $(which nvidia-smi) ]then    GPU_NAME_LIST=$(nvidia-smi --query-gpu=gpu_name --format=csv,noheader |sed >    GUESSED_GPU_COUNT=$(echo $GPU_NAME_LIST |wc -w)    echo "GPUs found ($GUESSED_GPU_COUNT)":    echo $GPU_NAME_LIST    # GUESSED_MACHINE_NAME=$(hostname)__$(echo $GPU_NAME_LIST |cut -d " " -f 1)    GUESSED_MACHINE_NAME=$(hostname)else    GUESSED_GPU_COUNT=1    GUESSED_MACHINE_NAME=dark_horsefiread -p "Total number of GPUs [$GUESSED_GPU_COUNT]: " -i 1 REVISE_TOTAL_GPUSREVISE_TOTAL_GPUS=${REVISE_TOTAL_GPUS:-$GUESSED_GPU_COUNT}
In order to accept the guessed number of GPUs, press Enter. Or, if guessed incorrectly, enter the correct value and press enter.
?. [Download and preprocess dataset; measure visualization performance]
Input dataset name, if not specified as the command line argument.if [ -z "$REVISE_DATASET" ]then    read -p "Dataset name [$REVISE_DATASET_DEFAULT]: " -i 1 REVISE_DATASET    REVISE_DATASET=${REVISE_DATASET:-$REVISE_DATASET_DEFAULT}fiecho REVISE_DATASET=$REVISE_DATASET
?. [Download and preprocess dataset; measure visualization performance]
Input machine name.read -p "Machine name [$GUESSED_MACHINE_NAME]: " -i 1 REVISE_MACHINE
REVISE_MACHINE=${REVISE_MACHINE:-$GUESSED_MACHINE_NAME}
echo REVISE_MACHINE=$REVISE_MACHINE
In order to accept the guessed machine name, press Enter. Or press another name and press Enter. Notice that the machine name appears further as the name of a subdirectory for performance log files.
?. [Download and preprocess dataset; measure visualization performance]
Compute and print the sufficient number of frame composition threads.REVISE_ASM_THREADS=$((2*$REVISE_TOTAL_GPUS))
echo REVISE_ASM_THREADS=$REVISE_ASM_THREADS
?. [Download and preprocess dataset; measure visualization performance]
Download and preprocess source dataset, which results in a ReVisE dataset.revise_prepare_dataset.sh $REVISE_DATASET
?. [Download and preprocess dataset; measure visualization performance]
Read dataset description.source $REVISE_DATASET/description.sh
?. [Download and preprocess dataset; measure visualization performance]
Prepare custom ReVisE Web server problem list files for testing the specified dataset.revise_webdata.js install test_datasets.json
revise_install_dataset.sh $REVISE_DATASET
?. [Download and preprocess dataset; measure visualization performance]
Prepare custom ReVisE Web server configuration files for testing.revise_hw_config.js install test_hw.json
revise_hw_config.js set nodes 1
revise_hw_config.js set assemble_threads_per_node $REVISE_ASM_THREADS
revise_hw_config.js set measure_time true
?. [Download and preprocess dataset; measure visualization performance]
Create directory for performance log files.LOGDIR=log/$REVISE_MACHINE/$REVISE_DATASET
mkdir -p $LOGDIR
?. [Download and preprocess dataset; measure visualization performance]
Process measurement results.revise_process_render_perf_logs.sh $LOGDIR
?. [Download and preprocess dataset; measure visualization performance]
Print results.cat $LOGDIR/total_avg.tsv
?. 
?. [Download and preprocess dataset]
Download and preprocess the dataset.revise_prepare_dataset.sh $REVISE_DATASET
If the download of the source dataset is interrupted due to an unstable internet connection, just repeat this step once again. The download will continue.
On rare occasion, the preprocessing may fail. In this case, the file $REVISE_DATASET/prepare.log will contain the word ERROR. If that happens, execute the following commands:find $REVISE_DATASET -name "*.s3dmm*" -exec rm {} \;rm $REVISE_DATASET/revise_readythen repeat this step once again (no downloading will be repeated).
?. [Measure visualization performance]
Measure the performance of visualization using ReVisE.
?. [Measure visualization performance]
Set the REVISE_GPUS environment variable to the number of GPUs to use in the test.REVISE_GPUS=1
?. [Measure visualization performance]
Set the REVISE_WORKERS environment variable to the number of rendering worker threads to use in the test.REVISE_WORKERS=1
?. [Measure visualization performance]
Write the number of GPUs and workers per GPU to use in the measurement to the ReVisE hardware configuration file.revise_hw_config.js set gpus_per_node $REVISE_GPUSrevise_hw_config.js set render_threads_per_node $REVISE_WORKERS
?. [Measure visualization performance]
Create directory for performance log files.LOGDIR=log/$REVISE_MACHINE/$REVISE_DATASETmkdir -p $LOGDIR
?. [Measure visualization performance]
Start ReVisE Web server.revise_web.sh
when the Web server is started for the first time, the script downloads and installsall necessary dependencies and builds two ReVisE modules that interoperate with the web server.This process takes a few seconds. When the server is started and ready to serve request, it displays the message"Starting web server"
?. [Measure visualization performance]
Prepare Web browser for measuring ReVisE performance.Open Web browser (we use Chrome and Firefox, other browser should work too)Type localhost:3000 in the address bar and press Enter.Maximize browser windowSelect problem: choose dataset nameSelect field. For each dataset, a specific field is used in the performance test - see the table below.rho_nufNutF 6. Open the Settings dialog. To do so press the button with the following icon:  7. Press Reset data; wait a few seconds  8. Open the Settings dialog again. Set the value of fovY (camera field of view angle [deg] in the Y direction) from the table below; Fields are shown as relative values; Time interval, ms = 1; Press Ok.11231119  9. Select Visualization mode MIP in a dropdown list on the left side of the window.  10. Move to the left the slider below the visualization mode selector.  11.Stop web server: go to terminal where the web server is running in and press Ctrl+C.  12.Go to the Web browser and refresh the window; return to the terminal again.  13. Start ReVisE Web server againrevise_web.sh13. Go to the Web browser. Open Colormap settings dialog pressing the button with the following icon:14. Press Ok.15. Stop web server; refresh browser window; return to terminal.16. Remove timestamp log file.rm $REVISE_ROOT_DIR/src/webserver/VsRendererDrawTimestamps.log
rho_nufNutF
11231119
?. [Measure visualization performance]
Measure ReVisE performance for specific hardware configuration.Start ReVisE Web server again.revise_web.sh 2. Wait till the last level is reported. The table below shows the last level number for each dataset, as well as the typical warming-up time - an estimation of time necessary to render the very first frame at the last level, for the minimal hardware configuration. Notice that the warming-up time will be eliminated in a future release of ReVisE.cascade203mwave5002hump33sphere1M02  3. Press the button (its the icon is presented below) 10 times, each time waiting till the last level is reported.  4. Stop web server; refresh browser window; return to terminal.  5. Move the timestamp log file to the log directory.mv $REVISE_ROOT_DIR/src/webserver/VsRendererDrawTimestamps.log $LOGDIR/VsRendererDrawTimestamps-$REVISE_GPUS-$REVISE_WORKERS-$REVISE_ASM_THREADS.log
cascade203mwave5002hump33sphere1M02
?. [Measure visualization performance]
Measure ReVisE performance for more hardware configurations. At this point, repeat sequence of steps , , ,  multiple times, each time setting different values of REVISE_GPUS and REVISE_WORKERS. For example, on a DGX-1 machine that has 8 GPUs, we would take values from the table below:111212314422524628744848941610881181612832
111212314422524628744848941610881181612832
?. [Measure visualization performance]
Process measurement results with the special tool.revise_process_render_perf_logs.sh $LOGDIR
?. [Measure visualization performance]
Print results.cat $LOGDIR/total_avg.tsv
?. [Prepare to measure ReVisE visualization performance]
Source ReVisE environment script.source /scripts/env.shwhere  is the path to the directory ReVisE repository was cloned into.
?. [Download and preprocess dataset]
Add the ReVisE dataset, prepared at the previous step, to the list of problems available to the ReVisE Web server.revise_install_dataset.sh $REVISE_DATASET
?. [Measure visualization performance]
Set the REVISE_ASM_THREADS environment variable to the number of threads used to compose frame of several rendered parts, and write its value into the ReVisE hardware configuration file.REVISE_ASM_THREADS=2revise_hw_config.js set assemble_threads_per_node $REVISE_ASM_THREADS
For the value of this variable, we typically specify twice the total number of GPUs installed on the system (not REVISE_GPUS, which is the number of GPUs used in one measurement!), and never change the value during the test.
?. [Download and preprocess dataset; measure visualization performance]
Check arguments; get dataset name from the first argument, or suggest the default dataset name.[ -z "$1" ] && REVISE_DATASET_DEFAULT=cascade || REVISE_DATASET="$1"
?. [Download and preprocess dataset; measure visualization performance]
Start performance measurement loop; alter ReVisE hardware configuration.REVISE_GPUS=1TOTAL_MEASUREMENT_COUNT=$(( REVISE_TOTAL_GPUS * 3 ))CURRENT_MEASUREMENT_NUMBER=1while (( REVISE_GPUS do    for REVISE_WORKERS_PER_GPU in 1 2 4; do        REVISE_WORKERS=$(( REVISE_WORKERS_PER_GPU * REVISE_GPUS ))        revise_hw_config.js set gpus_per_node $REVISE_GPUS        revise_hw_config.js set render_threads_per_node $REVISE_WORKERS
?. [Download and preprocess dataset; measure visualization performance]
Ask user to prepare the Web browser for the performance measurement, if necessary.        if [ -z "$REVISE_WEBCLIENT_INITIALIZED" ]        then            echo "Prepare Web browser for measuring ReVisE performance..."            ...            read -p "Press enter now to start the Web server"            revise_web.sh            ...            REVISE_WEBCLIENT_INITIALIZED=true        fi
?. [Download and preprocess dataset; measure visualization performance]
Do a performance measurement for the current values of parameters; move the log file; increase measurement number; continue with the next value of workers per GPU.        rm -f $REVISE_ROOT_DIR/src/webserver/VsRendererDrawTimestamps.log        echo ...        read -p "Press enter now to start the Web server"        revise_web.sh        echo ...        mv $REVISE_ROOT_DIR/src/webserver/VsRendererDrawTimestamps.log $LOGDIR/VsRendererDrawTimestamps-$REVISE_GPUS-$REVISE_WORKERS-$REVISE_ASM_THREADS.log        ...        # Increase measurement number        CURRENT_MEASUREMENT_NUMBER=$(( CURRENT_MEASUREMENT_NUMBER + 1 ))    done
?. [Download and preprocess dataset; measure visualization performance]
Continue with the next value of the number of GPUs.    if (( REVISE_GPUS     then        REVISE_GPUS=$((REVISE_GPUS*2))        if (( REVISE_GPUS > REVISE_TOTAL_GPUS ))        then            REVISE_GPUS=$REVISE_TOTAL_GPUS        fi    else        REVISE_GPUS=$((REVISE_GPUS*2))    fidone
?. [Download and preprocess dataset]
Set REVISE_MACHINE environment variable, e.g, to the value returned by the hostname command.REVISE_MACHINE=$(hostname)
Notice that the machine name appears further as the name of a subdirectory for performance log files.
?. [Compare test results with the expected results]
Compare results of rendering performance measurements obtained in your tests against our results.curl https://ftp.mpksoft.ru/revise_datasets/orig_log_processed.tar.gz |tar -zx
The expected result depends on the dataset and the target machine. The results obtained can be compared against our results. To do so, first download our log files, together with the results of processing:
This will result in a directory, named orig_log_processed. The content of the directory is structured in the same way as the log directory: it contains subdirectories /, each of which contains corresponding log-files and results of processing. In particular, there are files orig_log_processed///total_avg.tsv that can be compared against the results obtained by user. The orig_log_processed directory contains results for the following combination of MACHINE and DATASET:GeForcexx-TeslaxxxDGX-1xxxParameters of tested machines are as follows.CPU infoIntel i7-8700 CPU @ 3.20GHzIntel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHzIntel(R) Xeon(R) CPU E5-2698 v4CPU count122cores per CPU61220RAM, Gb16128512GPU infoGeForce 1060 GPU (6 GB memory, 1280 CUDA cores)Tesla V100-PCIE GPUs (32 GB memory, 5120 CUDA cores per GPU)V100-SXM2 GPUs (16 GB memory, 5120 CUDA cores per GPU)GPU count128remarks-Intel Optane 960 storage system-To compare your results against our results, find a closest match between your machine and our machine (GPU count, multiplied by the number of cores per GPU, is the most important parameter). Then compare the data in fileslog///total_avg.tsvandorig_log_processed///total_avg.tsv
?. [Compare test results with the expected results]
Compare results of preprocessing time in your tests against our results.ReVisE visualizes a dataset in a special format, obtained by preprocessing of the corresponding source dataset. The preprocessing is currently not parallelized (although different time steps can be preprocessed in parallel, the most time consuming preprocessing operations are done in a single thread of execution). Since we present preprocessing times in our paper, those times can also be compared with your test results.There is a preprocessing log file, named prepare.log, that is written to the subdirectory of the corresponding dataset. The file contains information about the time of various preprocessing stages, as well as the total preprocessing time. The total preprocessing time, in seconds, can be extracted from the prepare.log file using the following command:grep "finished: \\[Run the entire job" /prepare.log |sed -r "s/^.*+\\] ([^s]+)s.*$/\\1/"where  is the dataset name.
The table below presents total preprocessing times, in seconds, rounded off, that we have obtained on the Tesla machine (see table in Step 10).1458362271791
?. [Compare test results with the expected results]
Compare results of rendering performance measurements obtained in your tests against our results.curl https://ftp.mpksoft.ru/revise_datasets/orig_log_processed.tar.gz |tar -zx
The expected result depends on the dataset and the target machine. The results obtained can be compared against our results. To do so, first download our log files, together with the results of processing:
This will result in a directory, named orig_log_processed. The content of the directory is structured in the same way as the log directory: it contains subdirectories /, each of which contains corresponding log-files and results of processing. In particular, there are files orig_log_processed///total_avg.tsv that can be compared against the results obtained by user. The orig_log_processed directory contains results for the following combination of MACHINE and DATASET:GeForcexx-TeslaxxxDGX-1xxxParameters of tested machines are as follows.CPU infoIntel i7-8700 CPU @ 3.20GHzIntel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHzIntel(R) Xeon(R) CPU E5-2698 v4CPU count122cores per CPU61220RAM, Gb16128512GPU infoGeForce 1060 GPU (6 GB memory, 1280 CUDA cores)Tesla V100-PCIE GPUs (32 GB memory, 5120 CUDA cores per GPU)V100-SXM2 GPUs (16 GB memory, 5120 CUDA cores per GPU)GPU count128remarks-Intel Optane 960 storage system-To compare your results against our results, find a closest match between your machine and our machine (GPU count, multiplied by the number of cores per GPU, is the most important parameter). Then compare the data in fileslog///total_avg.tsvandorig_log_processed///total_avg.tsv
?. [Compare test results with the expected results]
Compare results of preprocessing time in your tests against our results.ReVisE visualizes a dataset in a special format, obtained by preprocessing of the corresponding source dataset. The preprocessing is currently not parallelized (although different time steps can be preprocessed in parallel, the most time consuming preprocessing operations are done in a single thread of execution). Since we present preprocessing times in our paper, those times can also be compared with your test results.There is a preprocessing log file, named prepare.log, that is written to the subdirectory of the corresponding dataset. The file contains information about the time of various preprocessing stages, as well as the total preprocessing time. The total preprocessing time, in seconds, can be extracted from the prepare.log file using the following command:grep "finished: \\[Run the entire job" /prepare.log |sed -r "s/^.*+\\] ([^s]+)s.*$/\\1/"where  is the dataset name.
The table below presents total preprocessing times, in seconds, rounded off, that we have obtained on the Tesla machine (see table in Step 10).1458362271791
?. [Download and preprocess dataset]
Prepare custom ReVisE Web server problem list files for testing the specified dataset.revise_webdata.js install test_datasets.json