diff --git a/scripts/run_1.14G_dp128_tp2_pp1_acc4_mbs1_seq2048_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp128_tp2_pp1_acc4_mbs1_seq2048_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f9b87028ee75d58b9d3a7508de821563f059f669
--- /dev/null
+++ b/scripts/run_1.14G_dp128_tp2_pp1_acc4_mbs1_seq2048_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp128_tp2_pp1_acc4_mbs1_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp128_tp2_pp1_acc4_mbs1_seq2048_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp2_tp128_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp2_tp128_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c6a6ab4ccd8738a16e252b4065729b3c5fe918a2
--- /dev/null
+++ b/scripts/run_1.14G_dp2_tp128_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp2_tp128_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp2_tp128_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp2_tp128_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab32k.sh b/scripts/run_1.14G_dp2_tp128_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f24e689165cb2faf07b9fa9a518d70c70ab6ca02
--- /dev/null
+++ b/scripts/run_1.14G_dp2_tp128_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp2_tp128_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp2_tp128_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp2_tp8_pp1_acc64_mbs4_seq2048_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp2_tp8_pp1_acc64_mbs4_seq2048_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5cba88aaff301ef96200c1d27004878619db5f14
--- /dev/null
+++ b/scripts/run_1.14G_dp2_tp8_pp1_acc64_mbs4_seq2048_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp2_tp8_pp1_acc64_mbs4_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp2_tp8_pp1_acc64_mbs4_seq2048_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp32_tp16_pp1_acc16_mbs4_seq2048_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp32_tp16_pp1_acc16_mbs4_seq2048_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..36cec2915952596c9ebef087a456cae665b11370
--- /dev/null
+++ b/scripts/run_1.14G_dp32_tp16_pp1_acc16_mbs4_seq2048_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp32_tp16_pp1_acc16_mbs4_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp32_tp16_pp1_acc16_mbs4_seq2048_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp4_tp1_pp2_acc16_mbs32_seq2048_zero1_tpmodeRED_vocab32k.sh b/scripts/run_1.14G_dp4_tp1_pp2_acc16_mbs32_seq2048_zero1_tpmodeRED_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..992ef340907d91a3cb4bab79003c706934d08f9a
--- /dev/null
+++ b/scripts/run_1.14G_dp4_tp1_pp2_acc16_mbs32_seq2048_zero1_tpmodeRED_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp1_pp2_acc16_mbs32_seq2048_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp1_pp2_acc16_mbs32_seq2048_zero1_tpmodeRED_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp4_tp2_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp4_tp2_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..6c8ac47e15f258a73871160636f05a5a174b2177
--- /dev/null
+++ b/scripts/run_1.14G_dp4_tp2_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp2_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp2_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp4_tp2_pp1_acc4_mbs2_seq32768_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp4_tp2_pp1_acc4_mbs2_seq32768_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..1ae6172b769dec80d6e6d9b36ee08d740a6e69fb
--- /dev/null
+++ b/scripts/run_1.14G_dp4_tp2_pp1_acc4_mbs2_seq32768_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp2_pp1_acc4_mbs2_seq32768_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp2_pp1_acc4_mbs2_seq32768_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp4_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp4_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..97a04d557de0a97fabd3bdf2831275ec5462b784
--- /dev/null
+++ b/scripts/run_1.14G_dp4_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp4_tp64_pp1_acc2_mbs16_seq8192_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp4_tp64_pp1_acc2_mbs16_seq8192_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9981641ef3e05a2a95e97698f6ad2d3de57d79eb
--- /dev/null
+++ b/scripts/run_1.14G_dp4_tp64_pp1_acc2_mbs16_seq8192_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp64_pp1_acc2_mbs16_seq8192_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp64_pp1_acc2_mbs16_seq8192_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp4_tp64_pp1_acc64_mbs2_seq8192_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp4_tp64_pp1_acc64_mbs2_seq8192_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b73136d0d1b5f8e842f84efd17ef1d81810014bc
--- /dev/null
+++ b/scripts/run_1.14G_dp4_tp64_pp1_acc64_mbs2_seq8192_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp64_pp1_acc64_mbs2_seq8192_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp64_pp1_acc64_mbs2_seq8192_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp8_tp1_pp1_acc16_mbs4_seq2048_zero1_tpmodeRED_vocab32k.sh b/scripts/run_1.14G_dp8_tp1_pp1_acc16_mbs4_seq2048_zero1_tpmodeRED_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e57cbdb130c4f8222ccdacfb05c7bfd5a5591b53
--- /dev/null
+++ b/scripts/run_1.14G_dp8_tp1_pp1_acc16_mbs4_seq2048_zero1_tpmodeRED_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp1_pp1_acc16_mbs4_seq2048_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp1_pp1_acc16_mbs4_seq2048_zero1_tpmodeRED_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp8_tp64_pp1_acc2_mbs128_seq2048_zero1_tpmodeRED_vocab32k.sh b/scripts/run_1.14G_dp8_tp64_pp1_acc2_mbs128_seq2048_zero1_tpmodeRED_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e9d50b1e715225144d32ca9e2809e4d475cde559
--- /dev/null
+++ b/scripts/run_1.14G_dp8_tp64_pp1_acc2_mbs128_seq2048_zero1_tpmodeRED_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp64_pp1_acc2_mbs128_seq2048_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp64_pp1_acc2_mbs128_seq2048_zero1_tpmodeRED_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp8_tp8_pp1_acc16_mbs4_seq8192_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp8_tp8_pp1_acc16_mbs4_seq8192_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2fb7094375146ca829fbba2a794c7c2e145b3629
--- /dev/null
+++ b/scripts/run_1.14G_dp8_tp8_pp1_acc16_mbs4_seq8192_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp8_pp1_acc16_mbs4_seq8192_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp8_pp1_acc16_mbs4_seq8192_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.14G_dp8_tp8_pp1_acc2_mbs128_seq2048_zero1_tpmodeALL_vocab32k.sh b/scripts/run_1.14G_dp8_tp8_pp1_acc2_mbs128_seq2048_zero1_tpmodeALL_vocab32k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8d67c8042ee4723d9951ef58538173443fbc19ac
--- /dev/null
+++ b/scripts/run_1.14G_dp8_tp8_pp1_acc2_mbs128_seq2048_zero1_tpmodeALL_vocab32k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp8_pp1_acc2_mbs128_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp8_pp1_acc2_mbs128_seq2048_zero1_tpmodeALL_vocab32k.yaml
diff --git a/scripts/run_1.34G_dp128_tp1_pp1_acc4_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp128_tp1_pp1_acc4_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..cfad9dbb32a893778ca084a966cc169657b6954c
--- /dev/null
+++ b/scripts/run_1.34G_dp128_tp1_pp1_acc4_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp128_tp1_pp1_acc4_mbs1_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp128_tp1_pp1_acc4_mbs1_seq8192_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp16_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp16_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..764c19c71348426ec27b9c25185874003a0de03d
--- /dev/null
+++ b/scripts/run_1.34G_dp16_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp16_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp16_tp32_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp16_tp32_pp1_acc8_mbs4_seq8192_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp16_tp32_pp1_acc8_mbs4_seq8192_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..df2c40234fed67921f655db0e3b938985943f30e
--- /dev/null
+++ b/scripts/run_1.34G_dp16_tp32_pp1_acc8_mbs4_seq8192_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp16_tp32_pp1_acc8_mbs4_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp16_tp32_pp1_acc8_mbs4_seq8192_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp1_tp16_pp1_acc16_mbs16_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp1_tp16_pp1_acc16_mbs16_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..4a2f53fef3234a6490f6541a61f52090c8d135cd
--- /dev/null
+++ b/scripts/run_1.34G_dp1_tp16_pp1_acc16_mbs16_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp1_tp16_pp1_acc16_mbs16_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp1_tp16_pp1_acc16_mbs16_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp1_tp16_pp4_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp1_tp16_pp4_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5eb5080ef4c2c38bd7862b635b935f9d095a8652
--- /dev/null
+++ b/scripts/run_1.34G_dp1_tp16_pp4_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp1_tp16_pp4_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp1_tp16_pp4_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..6a66d57d7aba5b3f46c3bf34db1f6f9706622a80
--- /dev/null
+++ b/scripts/run_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,160 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --reservation=nouamane_bench
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+# source /etc/profile.d/modules.sh # for some reason module isn't loaded
+# module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp1_tp2_pp8_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0a8e7763e407016e383ad4885e0e303cca96f1c8
--- /dev/null
+++ b/scripts/run_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,124 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp256_tp2_pp1_acc1_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp2_tp1_pp4_acc64_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp2_tp1_pp4_acc64_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..62aade40c2a353cef610c7bf3a53dc3fe9b4c7e2
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp1_pp4_acc64_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp1_pp4_acc64_mbs16_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp1_pp4_acc64_mbs16_seq2048_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8bb61c22f1fd7c35a7273c4b6b6e163749315ee9
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp2_tp1_pp8_acc64_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp2_tp4_pp1_acc16_mbs64_seq2048_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp2_tp4_pp1_acc16_mbs64_seq2048_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b0799103927653115f966aae6f2a7cded2aaadbf
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp4_pp1_acc16_mbs64_seq2048_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp4_pp1_acc16_mbs64_seq2048_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp4_pp1_acc16_mbs64_seq2048_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp2_tp4_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp2_tp4_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..77cd47cd1020815f615b7ee5fd9e2d40e05f1851
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp4_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp4_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp4_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b6f62b1152f37dc491dac595815140d7e83f2b45
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp2_tp4_pp8_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp2_tp64_pp1_acc8_mbs128_seq2048_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp2_tp64_pp1_acc8_mbs128_seq2048_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..595b2e642348b3da9a84ec91fd49b70d7930cca2
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp64_pp1_acc8_mbs128_seq2048_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp64_pp1_acc8_mbs128_seq2048_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp64_pp1_acc8_mbs128_seq2048_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp2_tp8_pp1_acc4_mbs4_seq32768_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp2_tp8_pp1_acc4_mbs4_seq32768_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7c76b0061ec80596dde21c385c503751f1216bf2
--- /dev/null
+++ b/scripts/run_1.34G_dp2_tp8_pp1_acc4_mbs4_seq32768_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp8_pp1_acc4_mbs4_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp8_pp1_acc4_mbs4_seq32768_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..69e62ca64ec42fe659b21a753279ad9d7f54590c
--- /dev/null
+++ b/scripts/run_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=normal
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp32_tp4_pp2_acc2_mbs64_seq4096_zero0_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp4_tp128_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp4_tp128_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d2586cc6d283a67a853c86d2d421d8ad41f89201
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp128_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp128_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp128_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..6fdb1afa75e7d6ad8318826950c35e571cd68e05
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=normal
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp4_tp16_pp1_acc2.0_mbs32_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp4_tp1_pp2_acc32_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp1_pp2_acc32_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..849b5b7078e53b2ea4a05fcdcb78ec39ba9f6903
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp1_pp2_acc32_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp1_pp2_acc32_mbs1_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp1_pp2_acc32_mbs1_seq8192_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp32_pp1_acc1_mbs32_seq32768_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp32_pp1_acc1_mbs32_seq32768_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..105eca95bbbf9ebf4d1364ef3e27f7f8d70452cd
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp32_pp1_acc1_mbs32_seq32768_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp32_pp1_acc1_mbs32_seq32768_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp32_pp1_acc1_mbs32_seq32768_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp4_pp1_acc1_mbs8_seq32768_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp4_pp1_acc1_mbs8_seq32768_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7eb2a62b2d6269968c875b334332e13f6b01203e
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp4_pp1_acc1_mbs8_seq32768_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp4_pp1_acc1_mbs8_seq32768_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp4_pp1_acc1_mbs8_seq32768_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp4_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp4_tp4_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b5a7b36101b13aa9fecde78bc0226e26837f7089
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp4_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp4_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp4_pp1_acc2_mbs64_seq8192_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp64_pp1_acc1_mbs8_seq32768_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp4_tp64_pp1_acc1_mbs8_seq32768_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..7021c4c89bbccd8b18d33ebb2474764e46913719
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp64_pp1_acc1_mbs8_seq32768_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp64_pp1_acc1_mbs8_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp64_pp1_acc1_mbs8_seq32768_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp64_pp1_acc2_mbs64_seq8192_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp64_pp1_acc2_mbs64_seq8192_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d975961e17370839e05d0ff8e25bb75cea386cbc
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp64_pp1_acc2_mbs64_seq8192_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp64_pp1_acc2_mbs64_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp64_pp1_acc2_mbs64_seq8192_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp64_pp1_acc4_mbs8_seq32768_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp64_pp1_acc4_mbs8_seq32768_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e62e0c44c05537f321f0f57b1f292e1d83555e4f
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp64_pp1_acc4_mbs8_seq32768_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp64_pp1_acc4_mbs8_seq32768_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp64_pp1_acc4_mbs8_seq32768_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0311a9e3e462e49b734868f41a8b6862bd6249f2
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp4_tp8_pp16_acc64_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_1.34G_dp4_tp8_pp1_acc1_mbs128_seq2048_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp4_tp8_pp1_acc1_mbs128_seq2048_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..a15157b93dc2e280cd2dab9d768427c50a203fd2
--- /dev/null
+++ b/scripts/run_1.34G_dp4_tp8_pp1_acc1_mbs128_seq2048_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp8_pp1_acc1_mbs128_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp8_pp1_acc1_mbs128_seq2048_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp64_tp2_pp1_acc2_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp64_tp2_pp1_acc2_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..00fd936ea390ed4cceeb9b14ec433ec8a74305ba
--- /dev/null
+++ b/scripts/run_1.34G_dp64_tp2_pp1_acc2_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp64_tp2_pp1_acc2_mbs1_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp64_tp2_pp1_acc2_mbs1_seq32768_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp8_tp2_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp8_tp2_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2f21ec6c08548fcbf892a2c5d39a1d6a6ff46a3b
--- /dev/null
+++ b/scripts/run_1.34G_dp8_tp2_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp2_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp2_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp8_tp4_pp1_acc64_mbs1_seq2048_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp8_tp4_pp1_acc64_mbs1_seq2048_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..528e96f04da94d888f12b133ab88e21126e61602
--- /dev/null
+++ b/scripts/run_1.34G_dp8_tp4_pp1_acc64_mbs1_seq2048_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp4_pp1_acc64_mbs1_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp4_pp1_acc64_mbs1_seq2048_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp8_tp64_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp8_tp64_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..86c55df3bc98cd4567bf2cefdac3c114a21e0e8f
--- /dev/null
+++ b/scripts/run_1.34G_dp8_tp64_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp64_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp64_pp1_acc16_mbs1_seq32768_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp8_tp64_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k.sh b/scripts/run_1.34G_dp8_tp64_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b27750f8b356c6990e679a651eef2664ea8d0c11
--- /dev/null
+++ b/scripts/run_1.34G_dp8_tp64_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp64_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp64_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k.yaml
diff --git a/scripts/run_1.34G_dp8_tp64_pp1_acc64_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh b/scripts/run_1.34G_dp8_tp64_pp1_acc64_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..6fc7fc22b101a0efd266fd91d9971dc057bda0c6
--- /dev/null
+++ b/scripts/run_1.34G_dp8_tp64_pp1_acc64_mbs1_seq8192_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp64_pp1_acc64_mbs1_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp64_pp1_acc64_mbs1_seq8192_zero1_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b179d2d6c7833f3b2dc05bae65d5ed3cbc90ec0a
--- /dev/null
+++ b/scripts/run_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp16_tp16_pp2_acc2_mbs8_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..48ad050c2724ac1b434a224c5af8dba624a4619a
--- /dev/null
+++ b/scripts/run_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,124 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp16_tp4_pp1_acc16_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ab7a83a38b3862a5d9cd4d0502e296c0586d53a7
--- /dev/null
+++ b/scripts/run_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp16_tp4_pp2_acc4_mbs4_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache.sh b/scripts/run_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache.sh
new file mode 100644
index 0000000000000000000000000000000000000000..dea523384b9ed62a17f8e09917dbad97d8b75b0d
--- /dev/null
+++ b/scripts/run_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp16_pp1_acc1_mbs16_seq4096_zero0_tpmodeALL_vocab131k_cache.yaml
+fi
diff --git a/scripts/run_3.57G_dp1_tp16_pp2_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp1_tp16_pp2_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..af456783fd8d15ca21cde0d6c683732b5b17b95d
--- /dev/null
+++ b/scripts/run_3.57G_dp1_tp16_pp2_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_3.57G_dp1_tp16_pp2_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_3.57G_dp1_tp16_pp2_acc1_mbs256_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache.sh b/scripts/run_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache.sh
new file mode 100644
index 0000000000000000000000000000000000000000..32b47534fa51597bed259eb457ca176aafa9fbb0
--- /dev/null
+++ b/scripts/run_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp1_pp16_acc15_mbs2_seq4096_zero0_tpmodeRED_vocab131k_cache.yaml
+fi
diff --git a/scripts/run_3.57G_dp1_tp1_pp32_acc4_mbs64_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp1_tp1_pp32_acc4_mbs64_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..de9b40d75de25e31e4f1a3440602637b22329b6b
--- /dev/null
+++ b/scripts/run_3.57G_dp1_tp1_pp32_acc4_mbs64_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_3.57G_dp1_tp1_pp32_acc4_mbs64_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_3.57G_dp1_tp1_pp32_acc4_mbs64_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache.sh b/scripts/run_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache.sh
new file mode 100644
index 0000000000000000000000000000000000000000..106636708de1c192c0de28f1eceefbf99a22e424
--- /dev/null
+++ b/scripts/run_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp1_pp8_acc64_mbs3_seq4096_zero0_tpmodeALL_vocab131k_cache.yaml
+fi
diff --git a/scripts/run_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache.sh b/scripts/run_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e6747dc55d5c1a6b9719b9f116afcf4678ae262f
--- /dev/null
+++ b/scripts/run_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=2
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp1_tp2_pp1_acc1_mbs8_seq4096_zero0_tpmodeALL_vocab131k_cache.yaml
+fi
diff --git a/scripts/run_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..15ce7fa91b6cf681505864aac110c3f71704b584
--- /dev/null
+++ b/scripts/run_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp2_tp32_pp8_acc32_mbs4_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b8442d0390218f44525500e9ed20ab2db06ef0fe
--- /dev/null
+++ b/scripts/run_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_3.57G_dp4_tp32_pp4_acc16_mbs4_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..04f5d63d457ae1cd128bce2df6862d7de7aad81f
--- /dev/null
+++ b/scripts/run_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp16_tp32_pp1_acc8_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_469G_dp1_tp16_pp4_acc32_mbs8_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp1_tp16_pp4_acc32_mbs8_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d7e8f5169033a328ea707649c33906a9d6cbfb05
--- /dev/null
+++ b/scripts/run_469G_dp1_tp16_pp4_acc32_mbs8_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_469G_dp1_tp16_pp4_acc32_mbs8_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_469G_dp1_tp16_pp4_acc32_mbs8_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_469G_dp2_tp16_pp2_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp2_tp16_pp2_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e44c360a9cc7ca489c653979b86ad9af1edfe2e0
--- /dev/null
+++ b/scripts/run_469G_dp2_tp16_pp2_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_469G_dp2_tp16_pp2_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_469G_dp2_tp16_pp2_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b63d81e460feb685dbebff9b11bba740b96eee9f
--- /dev/null
+++ b/scripts/run_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp32_tp1_pp2_acc8_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ded5cfe2e3cc74dfdcb2d330ae975a5308a4dfe4
--- /dev/null
+++ b/scripts/run_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp32_tp1_pp4_acc4_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..146d826f0d7f23647ae53a371cd4361de7624f72
--- /dev/null
+++ b/scripts/run_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_469G_dp4_tp2_pp16_acc32_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_469G_dp8_tp1_pp2_acc32_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_469G_dp8_tp1_pp2_acc32_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..bece883a389aacdb1b435fb5340605a18d3955f3
--- /dev/null
+++ b/scripts/run_469G_dp8_tp1_pp2_acc32_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_469G_dp8_tp1_pp2_acc32_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_469G_dp8_tp1_pp2_acc32_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_5.5G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l32_h4096_heads32.sh b/scripts/run_5.5G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l32_h4096_heads32.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d37cc7f5acb2fddaba1b1663b747284cc6ffcda1
--- /dev/null
+++ b/scripts/run_5.5G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l32_h4096_heads32.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_5.5G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l32_h4096_heads32    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_5.5G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l32_h4096_heads32.yaml
diff --git a/scripts/run_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8.sh b/scripts/run_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e87ad637199230c2308937f62076b36b646486e7
--- /dev/null
+++ b/scripts/run_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_78.7G_dp1_tp4_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab49k_gqa8.yaml
+fi
diff --git a/scripts/run_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache.sh b/scripts/run_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ebd807e8b21cd4f0a4a5963d21406982279d0456
--- /dev/null
+++ b/scripts/run_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+#SBATCH --job-name=bench_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+echo "Running script: $0"
+
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_8.86G_dp1_tp8_pp1_acc1_mbs512_seq4096_zero0_tpmodeRED_vocab131k_cache.yaml
+fi
diff --git a/scripts/run_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..85304403a54053607de375e87ff9b82440251409
--- /dev/null
+++ b/scripts/run_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_8.86G_dp4_tp4_pp2_acc64_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh b/scripts/run_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..69433baf48ae3debdb32fb838d6f20dd7de94909
--- /dev/null
+++ b/scripts/run_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_8.86G_dp8_tp1_pp2_acc16_mbs2_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e51cee17eed47df08b6bba3494d5e36e2bd32b33
--- /dev/null
+++ b/scripts/run_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:40:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_80G_dp1_tp8_pp8_acc256_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_80G_dp2_tp1_pp32_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_80G_dp2_tp1_pp32_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9db2d914cf73c32fd2e4791e9deea537b9d51591
--- /dev/null
+++ b/scripts/run_80G_dp2_tp1_pp32_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_80G_dp2_tp1_pp32_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=00:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+#SBATCH --exclude=ip-26-0-160-192,ip-26-0-171-102
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+# Disable wandb
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+echo "=== GPU Topology ==="
+nvidia-smi topo -m
+echo "=================="
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun --wait=0 --kill-on-bad-exit=1 torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    --max_restarts 0 \
+    --rdzv_conf timeout=60 \
+    /fsx/nouamane/projects/nanotron/run_train.py \
+    --config-file benchmark/configs/config_80G_dp2_tp1_pp32_acc128_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
diff --git a/scripts/run_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..3eb26c054f1b4325290297dd34aa8728b23fbe65
--- /dev/null
+++ b/scripts/run_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,124 @@
+#!/bin/bash
+#SBATCH --job-name=bench_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_80G_dp64_tp2_pp1_acc2_mbs2_seq4096_zero0_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh b/scripts/run_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8b67c06e4570b93b547c3169e36e5f5167b2a1ad
--- /dev/null
+++ b/scripts/run_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k.sh
@@ -0,0 +1,124 @@
+#!/bin/bash
+#SBATCH --job-name=bench_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=WARN # INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_80G_dp64_tp4_pp1_acc4_mbs1_seq4096_zero0_tpmodeRED_vocab131k.yaml
+fi
diff --git a/scripts/run_dp4_tp8_pp1_acc1_seq2048.sh b/scripts/run_dp4_tp8_pp1_acc1_seq2048.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c104236b0329098e36245603bf59fba6bff8dd1b
--- /dev/null
+++ b/scripts/run_dp4_tp8_pp1_acc1_seq2048.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_dp4_tp8_pp1_acc1_seq2048    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod 
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%x-%j.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=80         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_dp4_tp8_pp1_acc1_seq2048.yaml