diff --git a/config/cscs-ci.py b/config/cscs-ci.py
index e36392b115..0f8bc767ba 100644
--- a/config/cscs-ci.py
+++ b/config/cscs-ci.py
@@ -76,6 +76,7 @@ class ReframeSettings:
                         'access': ['--partition=cn-regression'],
                         'environs': ['builtin-gcc'],
                         'descr': 'Tsa compute nodes',
+                        'max_jobs': 10,
                         'resources': {
                             '_rfm_gpu': ['--gres=gpu:{num_gpus_per_node}'],
                         }
diff --git a/config/cscs.py b/config/cscs.py
index fe9349f8d5..c03c378742 100644
--- a/config/cscs.py
+++ b/config/cscs.py
@@ -300,6 +300,70 @@ class ReframeSettings:
                 }
             },
 
+            'arolla': {
+                'descr': 'Arolla MCH',
+                'hostnames': [r'arolla-\w+\d+'],
+                'modules_system': 'tmod',
+                'resourcesdir': '/apps/common/UES/reframe/resources',
+                'partitions': {
+                    'login': {
+                        'scheduler': 'local',
+                        'environs': ['PrgEnv-pgi', 'PrgEnv-pgi-nompi',
+                                     'PrgEnv-gnu', 'PrgEnv-gnu-nompi'],
+                        'descr': 'Arolla login nodes',
+                    },
+                    'pn': {
+                        'scheduler': 'nativeslurm',
+                        'access': ['--partition=pn-regression'],
+                        'environs': ['PrgEnv-pgi', 'PrgEnv-pgi-nompi',
+                                     'PrgEnv-gnu', 'PrgEnv-gnu-nompi'],
+                        'descr': 'Arolla post-processing nodes',
+                    },
+                    'cn': {
+                        'scheduler': 'nativeslurm',
+                        'access': ['--partition=cn-regression'],
+                        'environs': ['PrgEnv-gnu', 'PrgEnv-gnu-nompi',
+                                     'PrgEnv-pgi', 'PrgEnv-pgi-nompi'],
+                        'descr': 'Arolla compute nodes',
+                        'resources': {
+                            '_rfm_gpu': ['--gres=gpu:{num_gpus_per_node}'],
+                        }
+                    }
+                }
+            },
+
+            'tsa': {
+                'descr': 'Tsa MCH',
+                'hostnames': [r'tsa-\w+\d+'],
+                'modules_system': 'tmod',
+                'resourcesdir': '/apps/common/UES/reframe/resources',
+                'partitions': {
+                    'login': {
+                        'scheduler': 'local',
+                        'environs': ['PrgEnv-pgi', 'PrgEnv-pgi-nompi',
+                                     'PrgEnv-gnu', 'PrgEnv-gnu-nompi'],
+                        'descr': 'Tsa login nodes',
+                    },
+                    'pn': {
+                        'scheduler': 'nativeslurm',
+                        'access': ['--partition=pn-regression'],
+                        'environs': ['PrgEnv-pgi', 'PrgEnv-pgi-nompi',
+                                     'PrgEnv-gnu', 'PrgEnv-gnu-nompi'],
+                        'descr': 'Tsa post-processing nodes',
+                    },
+                    'cn': {
+                        'scheduler': 'nativeslurm',
+                        'access': ['--partition=cn-regression'],
+                        'environs': ['PrgEnv-gnu', 'PrgEnv-gnu-nompi',
+                                     'PrgEnv-pgi', 'PrgEnv-pgi-nompi'],
+                        'descr': 'Tsa compute nodes',
+                        'resources': {
+                            '_rfm_gpu': ['--gres=gpu:{num_gpus_per_node}'],
+                        }
+                    }
+                }
+            },
+
             'generic': {
                 'descr': 'Generic example system',
                 'partitions': {
@@ -378,41 +442,67 @@ class ReframeSettings:
                     'cxx': 'g++',
                     'ftn': 'gfortran',
                 },
-                'PrgEnv-cray-c2sm': {
-                    'modules': ['c2sm-rcm/1.00.00-kesch',
-                                'c2sm/cray-env/base'],
-                },
-                'PrgEnv-cray-c2sm-gpu': {
-                    'modules': ['c2sm-rcm/1.00.00-kesch',
-                                'c2sm/cray-env/gpu'],
+            },
+
+            'arolla': {
+                'PrgEnv-pgi-nompi': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-pgi/19.9'],
+                    'cc': 'pgcc',
+                    'cxx': 'pgc++',
+                    'ftn': 'pgf90',
                 },
-                'PrgEnv-pgi-c2sm': {
-                    'modules': ['c2sm-rcm/1.00.00-kesch',
-                                'c2sm/pgi-env/base'],
+                'PrgEnv-pgi': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-pgi/19.9'],
                     'cc': 'mpicc',
                     'cxx': 'mpicxx',
-                    'ftn': 'mpif90',
+                    'ftn': 'mpifort',
                 },
-                'PrgEnv-pgi-c2sm-gpu': {
-                    'modules': ['c2sm-rcm/1.00.00-kesch',
-                                'c2sm/pgi-env/gpu'],
+                'PrgEnv-gnu': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-gnu/19.2'],
                     'cc': 'mpicc',
                     'cxx': 'mpicxx',
-                    'ftn': 'mpif90',
+                    'ftn': 'mpifort',
+                },
+                'PrgEnv-gnu-nompi': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-gnu/19.2'],
+                    'cc': 'gcc',
+                    'cxx': 'g++',
+                    'ftn': 'gfortran',
+                },
+            },
+
+            'tsa': {
+                'PrgEnv-pgi-nompi': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-pgi/19.9'],
+                    'cc': 'pgcc',
+                    'cxx': 'pgc++',
+                    'ftn': 'pgf90',
                 },
-                'PrgEnv-gnu-c2sm': {
-                    'modules': ['c2sm-rcm/1.00.00-kesch',
-                                'c2sm/gnu-env/base'],
+                'PrgEnv-pgi': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-pgi/19.9'],
                     'cc': 'mpicc',
                     'cxx': 'mpicxx',
-                    'ftn': 'mpif90',
+                    'ftn': 'mpifort',
                 },
-                'PrgEnv-gnu-c2sm-gpu': {
-                    'modules': ['c2sm-rcm/1.00.00-kesch',
-                                'c2sm/gnu-env/gpu'],
+                'PrgEnv-gnu': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-gnu/19.2'],
                     'cc': 'mpicc',
                     'cxx': 'mpicxx',
-                    'ftn': 'mpif90',
+                    'ftn': 'mpifort',
+                },
+                'PrgEnv-gnu-nompi': {
+                    'type': 'ProgEnvironment',
+                    'modules': ['PrgEnv-gnu/19.2'],
+                    'cc': 'gcc',
+                    'cxx': 'g++',
+                    'ftn': 'gfortran',
                 },
             },
 
diff --git a/cscs-checks/cuda/cuda_checks.py b/cscs-checks/cuda/cuda_checks.py
index 83ec3ea1f4..4aa52827bb 100644
--- a/cscs-checks/cuda/cuda_checks.py
+++ b/cscs-checks/cuda/cuda_checks.py
@@ -5,16 +5,22 @@
 
 class CudaCheck(rfm.RegressionTest):
     def __init__(self):
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
         if self.current_system.name == 'kesch':
             self.valid_prog_environs += ['PrgEnv-cray-nompi',
                                          'PrgEnv-gnu-nompi']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.valid_prog_environs += ['PrgEnv-gnu-nompi']
 
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'CUDA', 'essentials')
+
         if self.current_system.name == 'kesch':
             self.modules = ['cudatoolkit/8.0.61']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.modules = ['cuda/10.1.243']
         else:
             self.modules = ['craype-accel-nvidia60']
 
@@ -23,6 +29,9 @@ def __init__(self):
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.nvidia_sm = '37'
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.nvidia_sm = '70'
 
         self.maintainers = ['AJ', 'SK']
         self.tags = {'production', 'craype', 'external-resources'}
@@ -87,6 +96,9 @@ def __init__(self):
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
             self.variables = {'G2G': '0'}
             self.num_gpus_per_node = 2
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.valid_prog_environs = ['PrgEnv-gnu']
+            self.num_gpus_per_node = 2
         else:
             self.variables = {'CRAY_CUDA_MPS': '1'}
 
diff --git a/cscs-checks/cuda/multi_gpu.py b/cscs-checks/cuda/multi_gpu.py
index fb085135be..c7fe4510c7 100644
--- a/cscs-checks/cuda/multi_gpu.py
+++ b/cscs-checks/cuda/multi_gpu.py
@@ -8,10 +8,10 @@
 @rfm.simple_test
 class GpuBandwidthCheck(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
-        self.valid_systems = ['kesch:cn', 'daint:gpu', 'dom:gpu', 'tiger:gpu']
+        self.valid_systems = ['kesch:cn', 'daint:gpu', 'dom:gpu', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-gnu']
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.valid_prog_environs = ['PrgEnv-gnu-nompi']
             self.exclusive_access = True
 
@@ -24,6 +24,8 @@ def __init__(self):
         nvidia_sm = '60'
         if self.current_system.name == 'kesch':
             nvidia_sm = '37'
+        elif self.current_system.name in ['arolla', 'tsa']:
+            nvidia_sm = '70'
 
         self.build_system.cxxflags = ['-I.', '-m64', '-arch=sm_%s' % nvidia_sm]
         self.sourcepath = 'bandwidthtestflex.cu'
@@ -41,8 +43,11 @@ def __init__(self):
         if self.current_system.name in ['daint', 'dom', 'tiger']:
             self.modules = ['craype-accel-nvidia60']
             self.num_gpus_per_node = 1
-        else:
-            self.modules = ['craype-accel-nvidia35']
+        elif self.current_system.name == 'kesch':
+            self.modules = ['cudatoolkit/8.0.61']
+            self.num_gpus_per_node = 8
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.modules = ['cuda/10.1.243']
             self.num_gpus_per_node = 8
 
         # perf_patterns and reference will be set by the sanity check function
@@ -50,6 +55,11 @@ def __init__(self):
         self.perf_patterns = {}
         self.reference = {}
         self.__bwref = {
+            # FIXME: reference values for Arolla and Tsa need to be updated
+            #        (sanity check fails if they are not defined)
+            'arolla:cn:h2d':   (7583, -0.1, None, 'MB/s'),
+            'arolla:cn:d2h':   (7584, -0.1, None, 'MB/s'),
+            'arolla:cn:d2d': (137408, -0.1, None, 'MB/s'),
             'daint:gpu:h2d':  (11881, -0.1, None, 'MB/s'),
             'daint:gpu:d2h':  (12571, -0.1, None, 'MB/s'),
             'daint:gpu:d2d': (499000, -0.1, None, 'MB/s'),
@@ -62,6 +72,9 @@ def __init__(self):
             'tiger:gpu:h2d': (0, None, None, 'MB/s'),
             'tiger:gpu:d2h': (0, None, None, 'MB/s'),
             'tiger:gpu:d2d': (0, None, None, 'MB/s'),
+            'tsa:cn:h2d':   (7583, -0.1, None, 'MB/s'),
+            'tsa:cn:d2h':   (7584, -0.1, None, 'MB/s'),
+            'tsa:cn:d2d': (137408, -0.1, None, 'MB/s'),
         }
         self.tags = {'diagnostic', 'benchmark', 'mch',
                      'craype', 'external-resources'}
diff --git a/cscs-checks/libraries/io/netcdf_compile_run.py b/cscs-checks/libraries/io/netcdf_compile_run.py
index a6ded7da52..bb82d93d91 100644
--- a/cscs-checks/libraries/io/netcdf_compile_run.py
+++ b/cscs-checks/libraries/io/netcdf_compile_run.py
@@ -18,7 +18,8 @@ def __init__(self, lang, linkage):
         self.linkage = linkage
         self.descr = lang_names[lang] + ' NetCDF ' + linkage.capitalize()
         self.valid_systems = ['daint:gpu', 'daint:mc',
-                              'dom:gpu', 'dom:mc', 'kesch:cn', 'tiger:gpu']
+                              'dom:gpu', 'dom:mc', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         if self.current_system.name in ['daint', 'dom', 'tiger']:
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
                                         'PrgEnv-intel', 'PrgEnv-pgi']
@@ -30,6 +31,9 @@ def __init__(self, lang, linkage):
 
             if lang != 'f90':
                 self.valid_prog_environs += ['PrgEnv-cray-nompi']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu-nompi', 'PrgEnv-pgi-nompi']
 
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'netcdf')
@@ -81,6 +85,22 @@ def setflags(self):
                     '-I$EBROOTNETCDFMINCPLUSPLUS/include',
                     '-I$EBROOTNETCDFMINFORTRAN/include'
                 ]
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.modules = ['netcdf', 'netcdf-c++', 'netcdf-fortran']
+            self.build_system.cppflags = [
+                '-I$EBROOTNETCDF/include',
+                '-I$EBROOTNETCDFMINCPLUSPLUS/include',
+                '-I$EBROOTNETCDFMINFORTRAN/include'
+            ]
+            self.build_system.ldflags = [
+                '-L$EBROOTNETCDF/lib',
+                '-L$EBROOTNETCDFMINCPLUSPLUS/lib',
+                '-L$EBROOTNETCDFMINFORTRAN/lib',
+                '-L$EBROOTNETCDF/lib64',
+                '-L$EBROOTNETCDFMINCPLUSPLUS/lib64',
+                '-L$EBROOTNETCDFMINFORTRAN/lib64',
+                '-lnetcdf', '-lnetcdf_c++4', '-lnetcdff'
+            ]
         else:
             self.build_system.ldflags = ['-%s' % self.linkage]
 
diff --git a/cscs-checks/mch/automatic_arrays_acc.py b/cscs-checks/mch/automatic_arrays_acc.py
index 9c76e00c3b..d8e6b7f38e 100644
--- a/cscs-checks/mch/automatic_arrays_acc.py
+++ b/cscs-checks/mch/automatic_arrays_acc.py
@@ -5,9 +5,9 @@
 @rfm.simple_test
 class AutomaticArraysCheck(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
-        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
+        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-cce', 'PrgEnv-pgi']
         if self.current_system.name in ['daint', 'dom', 'tiger']:
             self.modules = ['craype-accel-nvidia60']
         elif self.current_system.name == 'kesch':
@@ -19,6 +19,9 @@ def __init__(self):
                 'CRAY_ACCEL_TARGET': 'nvidia35',
                 'MV2_USE_CUDA': '1'
             }
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+
         # This tets requires an MPI compiler, although it uses a single task
         self.num_tasks = 1
         self.num_gpus_per_node = 1
@@ -31,7 +34,6 @@ def __init__(self):
             'time': sn.extractsingle(r'Timing:\s+(?P<time>\S+)',
                                      self.stdout, 'time', float)
         }
-
         self.arrays_reference = {
             'PrgEnv-cray': {
                 'daint:gpu': {'time': (5.7E-05, None, 0.15)},
@@ -52,11 +54,16 @@ def setup(self, partition, environ, **job_opts):
         if environ.name.startswith('PrgEnv-cray'):
             envname = 'PrgEnv-cray'
             self.build_system.fflags += ['-hacc', '-hnoomp']
+        elif environ.name.startswith('PrgEnv-cce'):
+            envname = 'PrgEnv-cce'
+            self.build_system.fflags += ['-hacc', '-hnoomp']
         elif environ.name.startswith('PrgEnv-pgi'):
             envname = 'PrgEnv-pgi'
             self.build_system.fflags += ['-acc']
             if self.current_system.name == 'kesch':
                 self.build_system.fflags += ['-ta=tesla,cc35']
+            elif self.current_system.name in ['arolla', 'tsa']:
+                self.build_system.fflags += ['-ta=tesla,cc70']
             elif self.current_system.name in ['daint', 'dom', 'tiger']:
                 self.build_system.fflags += ['-ta=tesla,cc60', '-Mnorpath']
         else:
diff --git a/cscs-checks/mch/collectives_halo.py b/cscs-checks/mch/collectives_halo.py
index 641a0d40cb..da22f93bd0 100644
--- a/cscs-checks/mch/collectives_halo.py
+++ b/cscs-checks/mch/collectives_halo.py
@@ -4,7 +4,8 @@
 
 class CollectivesBaseTest(rfm.RegressionTest):
     def __init__(self, variant, bench_reference):
-        self.valid_systems = ['dom:gpu', 'daint:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['dom:gpu', 'daint:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-gnu']
         self.variables = {'G2G': '1'}
         self.executable = 'build/src/comm_overlap_benchmark'
@@ -29,6 +30,18 @@ def __init__(self, variant, bench_reference):
                 '-DCUDA_COMPUTE_CAPABILITY="sm_37"'
             ]
             self.build_system.max_concurrency = 1
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.num_tasks = 32
+            self.num_gpus_per_node = 8
+            self.num_tasks_per_node = 16
+            self.num_tasks_per_socket = 8
+            self.modules = ['cmake']
+            self.build_system.config_opts += [
+                '-DMPI_VENDOR=openmpi',
+                '-DCUDA_COMPUTE_CAPABILITY="sm_70"'
+            ]
+            self.build_system.max_concurrency = 1
         elif self.current_system.name in {'daint', 'dom', 'tiger'}:
             self.num_tasks = 4
             self.num_gpus_per_node = 1
@@ -87,9 +100,6 @@ def __init__(self, variant, bench_reference):
             'dom': {
                 'elapsed_time': (ref, None, 0.15)
             },
-            '*': {
-                'elapsed_time': (ref, None, None)
-            }
         }
 
         self.maintainers = ['AJ', 'MKr']
@@ -97,7 +107,7 @@ def __init__(self, variant, bench_reference):
 
     def setup(self, *args, **kwargs):
         super().setup(*args, **kwargs)
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.job.launcher.options = ['--distribution=block:block',
                                          '--cpu_bind=q']
 
@@ -116,7 +126,7 @@ def __init__(self, variant):
                                  'nocomm':  0.0171947,
                                  'nocomp':  0.0137893,
                                  'default': 0.0138493
-                             }
+                             },
                          })
         self.strict_check = False
         self.sourcesdir = 'https://github.com/eth-cscs/comm_overlap_bench.git'
@@ -137,7 +147,7 @@ def __init__(self, variant):
                                  'nocomm':  0.978306,
                                  'nocomp':  1.36716,
                                  'default': 2.53509
-                             }
+                             },
                          })
         self.sourcesdir = 'https://github.com/eth-cscs/comm_overlap_bench.git'
         self.prebuild_cmd = ['git checkout barebones']
diff --git a/cscs-checks/mch/cuda_stress_test.py b/cscs-checks/mch/cuda_stress_test.py
index 1a97cb409a..a7c90ca127 100644
--- a/cscs-checks/mch/cuda_stress_test.py
+++ b/cscs-checks/mch/cuda_stress_test.py
@@ -5,16 +5,19 @@
 @rfm.simple_test
 class CudaStressTest(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.descr = 'MCH CUDA stress test'
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-gnu-nompi']
             self.modules = ['cudatoolkit/8.0.61']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu-nompi']
+            self.modules = ['cuda/10.1.243']
         else:
             self.valid_prog_environs = ['PrgEnv-gnu']
-            self.modules = ['craype-accel-nvidia60']
 
         self.sourcepath = 'cuda_stencil_test.cu'
         self.build_system = 'SingleSource'
diff --git a/cscs-checks/mch/gpu_direct_acc.py b/cscs-checks/mch/gpu_direct_acc.py
index d4f7cad48f..1b16c4e369 100644
--- a/cscs-checks/mch/gpu_direct_acc.py
+++ b/cscs-checks/mch/gpu_direct_acc.py
@@ -7,10 +7,9 @@
 @rfm.simple_test
 class GpuDirectAccCheck(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.descr = 'tests gpu-direct for Fortran OpenACC'
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
-
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi']
         if self.current_system.name in ['daint', 'dom', 'tiger']:
             self.modules = ['craype-accel-nvidia60']
@@ -36,6 +35,14 @@ def __init__(self):
             self.num_tasks = 8
             self.num_gpus_per_node = 8
             self.num_tasks_per_node = 8
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.variables = {
+                'G2G': '1'
+            }
+            self.num_tasks = 8
+            self.num_gpus_per_node = 8
+            self.num_tasks_per_node = 8
 
         self.sourcepath = 'gpu_direct_acc.F90'
         self.build_system = 'SingleSource'
@@ -57,5 +64,7 @@ def setup(self, partition, environ, **job_opts):
                 self.build_system.fflags += ['-ta=tesla:cc60', '-Mnorpath']
             elif self.current_system.name == 'kesch':
                 self.build_system.fflags += ['-ta=tesla:cc35']
+            elif self.current_system.name in ['arolla', 'tsa']:
+                self.build_system.fflags += ['-ta=tesla:cc70']
 
         super().setup(partition, environ, **job_opts)
diff --git a/cscs-checks/mch/gpu_direct_cuda.py b/cscs-checks/mch/gpu_direct_cuda.py
index de0cadac53..302b8bd812 100644
--- a/cscs-checks/mch/gpu_direct_cuda.py
+++ b/cscs-checks/mch/gpu_direct_cuda.py
@@ -7,7 +7,8 @@
 class GpuDirectCudaCheck(rfm.RegressionTest):
     def __init__(self):
         self.descr = 'tests gpu-direct for CUDA'
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn',
+                              'tiger:gpu', 'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-gnu']
         self.sourcepath = 'gpu_direct_cuda.cu'
         self.build_system = 'SingleSource'
@@ -25,6 +26,13 @@ def __init__(self):
                 'G2G': '1',
             }
             self.build_system.cxxflags = ['-ccbin', 'mpicxx', '-arch=sm_37']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu']
+            self.variables = {
+                'G2G': '1',
+            }
+            self.build_system.cxxflags = ['-ccbin', 'mpicxx', '-arch=sm_70']
 
         self.num_tasks = 2
         self.num_gpus_per_node = 1
diff --git a/cscs-checks/mch/openacc_cuda_mpi_cppstd.py b/cscs-checks/mch/openacc_cuda_mpi_cppstd.py
index 90aad42187..fcc88ec05d 100644
--- a/cscs-checks/mch/openacc_cuda_mpi_cppstd.py
+++ b/cscs-checks/mch/openacc_cuda_mpi_cppstd.py
@@ -5,12 +5,11 @@
 @rfm.simple_test
 class OpenaccCudaCpp(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.descr = 'test for OpenACC, CUDA, MPI, and C++'
         self.valid_systems = ['daint:gpu', 'dom:gpu', 'tiger:gpu',
-                              'kesch:cn', 'arolla:cn', 'tsa:cn', 'tiger:gpu']
+                              'arolla:cn', 'kesch:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-cce', 'PrgEnv-cray',
-                                    'PrgEnv-pgi', 'PrgEnv-gnu']
+                                    'PrgEnv-pgi']
         self.build_system = 'Make'
         self.build_system.fflags = ['-O2']
 
@@ -35,28 +34,14 @@ def __init__(self):
                 'MV2_USE_CUDA': '1',
                 'G2G': '1'
             }
-        elif self.current_system.name == 'arolla':
+        elif self.current_system.name in ['arolla', 'tsa']:
             self.exclusive_access = True
-            self.modules = ['cuda92/toolkit/9.2.88',
-                            'craype-accel-nvidia70']
+            self.modules = ['cuda/10.1.243']
             self.num_tasks = 8
             self.num_tasks_per_node = 8
             self.num_gpus_per_node = 8
             self.build_system.options = ['NVCC_FLAGS="-arch=compute_70"']
             self.variables = {
-                'MV2_USE_CUDA': '1',
-                'G2G': '1'
-            }
-        elif self.current_system.name == 'tsa':
-            self.exclusive_access = True
-            self.modules = ['cuda10.0/toolkit/10.0.130',
-                            'craype-accel-nvidia70']
-            self.num_tasks = 8
-            self.num_tasks_per_node = 8
-            self.num_gpus_per_node = 8
-            self.build_system.options = ['NVCC_FLAGS="-arch=compute_70"']
-            self.variables = {
-                'MV2_USE_CUDA': '1',
                 'G2G': '1'
             }
 
@@ -69,19 +54,6 @@ def setup(self, partition, environ, **job_opts):
         if environ.name.startswith('PrgEnv-cray'):
             self.build_system.fflags += ['-hacc', '-hnoomp']
 
-        elif environ.name.startswith('PrgEnv-cce'):
-            self.build_system.fflags += ['-hacc', '-hnoomp']
-            if self.current_system.name == 'arolla':
-                self.build_system.ldflags = [
-                    '-L/cm/shared/apps/cuda92/toolkit/9.2.88/lib64',
-                    '-lcublas', '-lcudart'
-                ]
-            elif self.current_system.name == 'tsa':
-                self.build_system.ldflags = [
-                    '-L/cm/shared/apps/cuda10.0/toolkit/10.0.130/lib64',
-                    '-lcublas', '-lcudart'
-                ]
-
         elif environ.name.startswith('PrgEnv-pgi'):
             self.build_system.fflags += ['-acc']
             if self.current_system.name in ['daint', 'dom', 'tiger']:
@@ -95,19 +67,11 @@ def setup(self, partition, environ, **job_opts):
                     '-L/global/opt/nvidia/cudatoolkit/8.0.61/lib64',
                     '-lcublas', '-lcudart'
                 ]
-            elif self.current_system.name == 'arolla':
-                self.build_system.fflags += ['-ta=tesla,cc70,cuda10.0']
+            elif self.current_system.name in ['arolla', 'tsa']:
+                self.build_system.fflags += ['-ta=tesla,cc70,cuda10.1']
                 self.build_system.ldflags = [
-                    '-acc', '-ta:tesla:cc70,cuda10.0', '-lstdc++',
-                    '-L/cm/shared/apps/cuda92/toolkit/9.2.88/lib64',
-                    '-lcublas', '-lcudart'
-                ]
-            elif self.current_system.name == 'tsa':
-                self.build_system.fflags += ['-ta=tesla,cc70,cuda10.0']
-                self.build_system.ldflags = [
-                    '-acc', '-ta:tesla:cc70,cuda10.0', '-lstdc++',
-                    '-L/cm/shared/apps/cuda10.0/toolkit/10.0.130/lib64',
-                    '-lcublas', '-lcudart'
+                    '-acc', '-ta:tesla:cc70,cuda10.1', '-lstdc++',
+                    '-L$EBROOTCUDA/lib64', '-lcublas', '-lcudart'
                 ]
 
         elif environ.name.startswith('PrgEnv-gnu'):
@@ -116,13 +80,9 @@ def setup(self, partition, environ, **job_opts):
                 self.build_system.ldflags += [
                     '-L/global/opt/nvidia/cudatoolkit/8.0.61/lib64'
                 ]
-            if self.current_system.name == 'arolla':
+            elif self.current_system.name in ['arolla', 'tsa']:
                 self.build_system.ldflags += [
-                    '-L/cm/shared/apps/cuda92/toolkit/9.2.88/lib64'
+                    '-L$EBROOTCUDA/lib64', '-lcublas', '-lcudart'
                 ]
-            if self.current_system.name == 'tsa':
-                self.build_system.ldflags += [
-                    '-L/cm/shared/apps/cuda10.0/toolkit/10.0.130/lib64']
-            self.build_system.ldflags += ['-lcublas', '-lcudart']
 
         super().setup(partition, environ, **job_opts)
diff --git a/cscs-checks/microbenchmarks/alloc_speed/alloc_speed.py b/cscs-checks/microbenchmarks/alloc_speed/alloc_speed.py
index 3a3a7de168..5e695fd159 100644
--- a/cscs-checks/microbenchmarks/alloc_speed/alloc_speed.py
+++ b/cscs-checks/microbenchmarks/alloc_speed/alloc_speed.py
@@ -15,7 +15,9 @@ def __init__(self, hugepages):
                               'tiger:gpu']
         self.valid_prog_environs = ['PrgEnv-gnu']
         if hugepages == 'no':
-            self.valid_systems += ['kesch:cn', 'kesch:pn']
+            self.valid_systems += ['kesch:cn', 'kesch:pn',
+                                   'arolla:cn', 'arolla:pn',
+                                   'tsa:cn', 'tsa:pn']
         else:
             if self.current_system.name in {'dom', 'daint', 'tiger'}:
                 self.modules = ['craype-hugepages%s' % hugepages]
@@ -52,9 +54,6 @@ def __init__(self, hugepages):
                 'kesch:pn': {
                     'time': (0.70, None, 0.10, 's')
                 },
-                '*': {
-                    'time': (0, None, None, 's')
-                }
             },
             '2M': {
                 'dom:gpu': {
diff --git a/cscs-checks/microbenchmarks/dgemm/dgemm.py b/cscs-checks/microbenchmarks/dgemm/dgemm.py
index 49621fd658..e6efd535e3 100644
--- a/cscs-checks/microbenchmarks/dgemm/dgemm.py
+++ b/cscs-checks/microbenchmarks/dgemm/dgemm.py
@@ -17,12 +17,14 @@ def __init__(self):
         self.valid_systems = [
             'daint:gpu', 'daint:mc',
             'dom:gpu', 'dom:mc',
-            'kesch:cn', 'kesch:pn', 'tiger:gpu'
+            'kesch:cn', 'kesch:pn', 'tiger:gpu',
+            'arolla:cn', 'arolla:pn',
+            'tsa:cn', 'tsa:pn'
         ]
 
         if self.current_system.name in ['daint', 'dom', 'tiger']:
             self.valid_prog_environs = ['PrgEnv-gnu', 'PrgEnv-intel']
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.valid_prog_environs = ['PrgEnv-gnu-nompi']
 
         self.num_tasks = 0
@@ -62,7 +64,9 @@ def setup(self, partition, environ, **job_opts):
             self.num_cpus_per_task = 36
         elif partition.fullname in ['tiger:gpu']:
             self.num_cpus_per_task = 18
-        elif partition.fullname in ['kesch:cn', 'kesch:pn']:
+        elif partition.fullname in ['arolla:cn', 'arolla:pn',
+                                    'kesch:cn', 'kesch:pn',
+                                    'tsa:cn', 'tsa:pn']:
             self.num_cpus_per_task = 12
             self.build_system.cflags += ['-I$EBROOTOPENBLAS/include']
             self.build_system.ldflags = ['-L$EBROOTOPENBLAS/lib', '-lopenblas',
diff --git a/cscs-checks/microbenchmarks/gpu_burn/gpu_burn_test.py b/cscs-checks/microbenchmarks/gpu_burn/gpu_burn_test.py
index aacf6eb5fe..fdd565784e 100644
--- a/cscs-checks/microbenchmarks/gpu_burn/gpu_burn_test.py
+++ b/cscs-checks/microbenchmarks/gpu_burn/gpu_burn_test.py
@@ -7,8 +7,9 @@
 @rfm.simple_test
 class GpuBurnTest(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu',
+                              'kesch:cn', 'tiger:gpu'
+                              'arolla:cn', 'tsa:cn']
         self.descr = 'GPU burn test'
         self.valid_prog_environs = ['PrgEnv-gnu']
 
@@ -22,6 +23,12 @@ def __init__(self):
             self.executable_opts = ['-d', '40']
             self.num_gpus_per_node = 16
             gpu_arch = '37'
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.modules = ['cuda/10.1.243']
+            self.executable_opts = ['-d', '40']
+            self.num_gpus_per_node = 8
+            gpu_arch = '70'
         elif self.current_system.name in {'daint', 'dom', 'tiger'}:
             self.modules = ['craype-accel-nvidia60']
             self.executable_opts = ['-d', '20']
@@ -60,10 +67,6 @@ def __init__(self):
                 'perf': (950, -0.10, None, 'Gflop/s'),
                 'max_temp': (0, None, None, 'Celsius')
             },
-            '*': {
-                'perf': (0, None, None, 'Gflop/s'),
-                'max_temp': (0, None, None, 'Celsius')
-            }
         }
 
         self.num_tasks = 0
diff --git a/cscs-checks/microbenchmarks/kernel_latency/kernel_latency.py b/cscs-checks/microbenchmarks/kernel_latency/kernel_latency.py
index 4361a2fe4d..7df2ac78f3 100644
--- a/cscs-checks/microbenchmarks/kernel_latency/kernel_latency.py
+++ b/cscs-checks/microbenchmarks/kernel_latency/kernel_latency.py
@@ -8,7 +8,8 @@ class KernelLatencyTest(rfm.RegressionTest):
     def __init__(self, kernel_version):
         # List known partitions here so as to avoid specifying them every time
         # with --system
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.num_tasks = 0
         self.num_tasks_per_node = 1
         self.sourcepath = 'kernel_latency.cu'
@@ -23,8 +24,13 @@ def __init__(self, kernel_version):
         elif self.current_system.name == 'kesch':
             self.num_gpus_per_node = 16
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi']
-            self.modules = ['craype-accel-nvidia35']
+            self.modules = ['cudatoolkit/8.0.61']
             gpu_arch = '37'
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.num_gpus_per_node = 8
+            self.valid_prog_environs = ['PrgEnv-pgi']
+            self.modules = ['cuda/10.1.243']
+            gpu_arch = '70'
         else:
             # Enable test when running on an unknown system
             self.num_gpus_per_node = 1
@@ -66,11 +72,8 @@ def __init__(self, kernel_version):
                     'latency': (6.6, None, 0.10, 'us')
                 },
                 'kesch:cn': {
-                    'latency': (12.0, None, 0.10, 'us')
+                    'latency': (13.7, None, 0.10, 'us')
                 },
-                '*': {
-                    'latency': (0.0, None, None, 'us')
-                }
             },
             'async': {
                 'dom:gpu': {
@@ -82,9 +85,6 @@ def __init__(self, kernel_version):
                 'kesch:cn': {
                     'latency': (5.7, None, 0.10, 'us')
                 },
-                '*': {
-                    'latency': (0.0, None, None, 'us')
-                }
             },
         }
 
diff --git a/cscs-checks/microbenchmarks/mpi/halo_cell_exchange.py b/cscs-checks/microbenchmarks/mpi/halo_cell_exchange.py
index 697a518eee..2eed26f42f 100644
--- a/cscs-checks/microbenchmarks/mpi/halo_cell_exchange.py
+++ b/cscs-checks/microbenchmarks/mpi/halo_cell_exchange.py
@@ -10,7 +10,8 @@ def __init__(self):
         self.sourcepath = 'halo_cell_exchange.c'
         self.build_system = 'SingleSource'
         self.build_system.cflags = ['-O2']
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi',
                                     'PrgEnv-gnu']
         self.num_tasks = 6
@@ -95,17 +96,6 @@ def __init__(self):
                 'time_6_10000': (1.448979e-05, None, 0.50, 's'),
                 'time_6_1000000': (8.432294e-04, None, 0.50, 's')
             },
-            '*': {
-                'time_2_10': (0, None, None, 's'),
-                'time_2_10000': (0, None, None, 's'),
-                'time_2_1000000': (0, None, None, 's'),
-                'time_4_10': (0, None, None, 's'),
-                'time_4_10000': (0, None, None, 's'),
-                'time_4_1000000': (0, None, None, 's'),
-                'time_6_10': (0, None, None, 's'),
-                'time_6_10000': (0, None, None, 's'),
-                'time_6_1000000': (0, None, None, 's')
-            }
         }
 
         self.maintainers = ['AJ']
diff --git a/cscs-checks/microbenchmarks/osu/osu_tests.py b/cscs-checks/microbenchmarks/osu/osu_tests.py
index 5f4998eff5..9f2386309e 100644
--- a/cscs-checks/microbenchmarks/osu/osu_tests.py
+++ b/cscs-checks/microbenchmarks/osu/osu_tests.py
@@ -54,15 +54,19 @@ def __init__(self, variant):
 @rfm.simple_test
 class FlexAlltoallTest(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.valid_systems = ['daint:gpu', 'daint:mc',
                               'dom:gpu', 'dom:mc', 'tiger:gpu',
-                              'kesch:cn', 'kesch:pn', 'leone:normal']
+                              'kesch:cn', 'kesch:pn',
+                              'arolla:cn', 'arolla:pn',
+                              'tsa:cn', 'tsa:pn']
         self.valid_prog_environs = ['PrgEnv-cray']
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
                                         'PrgEnv-intel']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu', 'PrgEnv-pgi']
 
         self.descr = 'Flexible Alltoall OSU test'
         self.build_system = 'Make'
@@ -152,6 +156,9 @@ def __init__(self):
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu', 'PrgEnv-pgi']
         else:
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
                                         'PrgEnv-intel']
@@ -172,7 +179,8 @@ class P2PCPUBandwidthTest(P2PBaseTest):
     def __init__(self):
         super().__init__()
         self.valid_systems = ['daint:gpu', 'daint:mc', 'tiger:gpu',
-                              'dom:gpu', 'dom:mc', 'kesch:cn']
+                              'dom:gpu', 'dom:mc', 'kesch:cn',
+                              'arolla:cn', 'tsa:cn']
         self.executable = './p2p_osu_bw'
         self.executable_opts = ['-x', '100', '-i', '1000']
 
@@ -196,9 +204,6 @@ def __init__(self):
             'kesch:cn': {
                 'bw': (6311.48, -0.15, None, 'MB/s')
             },
-            '*': {
-                'bw': (0, None, None, 'MB/s')
-            }
         }
         self.perf_patterns = {
             'bw': sn.extractsingle(r'^4194304\s+(?P<bw>\S+)',
@@ -212,7 +217,8 @@ class P2PCPULatencyTest(P2PBaseTest):
     def __init__(self):
         super().__init__()
         self.valid_systems = ['daint:gpu', 'daint:mc', 'tiger:gpu',
-                              'dom:gpu', 'dom:mc', 'kesch:cn']
+                              'dom:gpu', 'dom:mc', 'kesch:cn',
+                              'arolla:cn', 'tsa:cn']
         self.executable_opts = ['-x', '100', '-i', '1000']
 
         self.executable = './p2p_osu_latency'
@@ -251,7 +257,8 @@ def __init__(self):
 class G2GBandwidthTest(P2PBaseTest):
     def __init__(self):
         super().__init__()
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.num_gpus_per_node = 1
         self.executable = './p2p_osu_bw'
         self.executable_opts = ['-x', '100', '-i', '1000', '-d',
@@ -282,6 +289,10 @@ def __init__(self):
         elif self.current_system.name == 'kesch':
             self.modules = ['cudatoolkit/8.0.61']
             self.variables = {'MV2_USE_CUDA': '1'}
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.modules = ['cuda/10.1.243']
+            self.build_system.ldflags = ['-L$EBROOTCUDA/lib64',
+                                         '-lcudart', '-lcuda']
 
         self.build_system.cppflags = ['-D_ENABLE_CUDA_']
 
@@ -291,7 +302,8 @@ def __init__(self):
 class G2GLatencyTest(P2PBaseTest):
     def __init__(self):
         super().__init__()
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.num_gpus_per_node = 1
         self.executable = './p2p_osu_latency'
         self.executable_opts = ['-x', '100', '-i', '1000', '-d',
@@ -322,5 +334,9 @@ def __init__(self):
         elif self.current_system.name == 'kesch':
             self.modules = ['cudatoolkit/8.0.61']
             self.variables = {'MV2_USE_CUDA': '1'}
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.modules = ['cuda/10.1.243']
+            self.build_system.ldflags = ['-L$EBROOTCUDA/lib64',
+                                         '-lcudart', '-lcuda']
 
         self.build_system.cppflags = ['-D_ENABLE_CUDA_']
diff --git a/cscs-checks/microbenchmarks/stream/stream.py b/cscs-checks/microbenchmarks/stream/stream.py
index fc34cfa229..6a96315828 100644
--- a/cscs-checks/microbenchmarks/stream/stream.py
+++ b/cscs-checks/microbenchmarks/stream/stream.py
@@ -15,8 +15,8 @@ def __init__(self):
         self.descr = 'STREAM Benchmark'
         self.exclusive_access = True
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'kesch:pn', 'leone:normal',
-                              'tiger:gpu']
+                              'kesch:cn', 'kesch:pn', 'tiger:gpu',
+                              'arolla:cn', 'arolla:pn', 'tsa:cn', 'tsa:pn']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
                                     'PrgEnv-intel', 'PrgEnv-pgi',
                                     'PrgEnv-cray_classic']
@@ -36,12 +36,17 @@ def __init__(self):
             self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
             cray_flags = self.prgenv_flags['PrgEnv-cray_classic']
             self.prgenv_flags['PrgEnv-cray'] = cray_flags
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu']
 
         self.sourcepath = 'stream.c'
         self.build_system = 'SingleSource'
         self.num_tasks = 1
         self.num_tasks_per_node = 1
         self.stream_cpus_per_task = {
+            'arolla:cn': 16,
+            'arolla:pn': 16,
             'daint:gpu': 12,
             'daint:mc': 36,
             'dom:gpu': 12,
@@ -50,6 +55,8 @@ def __init__(self):
             'kesch:pn': 24,
             'leone:normal': 16,
             'monch:compute': 20,
+            'tsa:cn': 16,
+            'tsa:pn': 16,
         }
         self.variables = {
             'OMP_PLACES': 'threads',
@@ -85,8 +92,6 @@ def __init__(self):
                 'dom:mc': {'triad': (87500, -0.05, None, 'MB/s')},
                 'kesch:cn': {'triad': (47000, -0.05, None, 'MB/s')},
                 'kesch:pn': {'triad': (84400, -0.05, None, 'MB/s')},
-                'leone:normal': {'triad': (44767.0, -0.05, None, 'MB/s')},
-                '*': {'triad': (0.0, None, None, 'MB/s')},
             },
             'PrgEnv-intel': {
                 'daint:gpu': {'triad': (59500, -0.05, None, 'MB/s')},
diff --git a/cscs-checks/prgenv/helloworld.py b/cscs-checks/prgenv/helloworld.py
index a06d4dae5e..ea15475e3c 100644
--- a/cscs-checks/prgenv/helloworld.py
+++ b/cscs-checks/prgenv/helloworld.py
@@ -18,17 +18,17 @@ def __init__(self, variant, lang, linkage):
         self.sourcepath = 'hello_world'
         self.build_system = 'SingleSource'
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'leone:normal', 'tiger:gpu']
+                              'kesch:cn', 'tiger:gpu', 'arolla:cn', 'arolla:pn',
+                              'tsa:cn', 'tsa:pn']
 
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-cray_classic',
                                     'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi']
 
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['kesch', 'arolla', 'tsa']:
             self.exclusive_access = True
 
         # Removing static compilation from kesch
-        if (self.current_system.name in ['kesch', 'leone'] and
-            linkage == 'static'):
+        if (self.current_system.name in ['kesch'] and linkage == 'static'):
             self.valid_prog_environs = []
 
         self.compilation_time_seconds = None
@@ -118,7 +118,7 @@ def cray_linker_workaround(self):
 class HelloWorldTestSerial(HelloWorldBaseTest):
     def __init__(self, lang, linkage):
         super().__init__('serial', lang, linkage)
-        self.valid_systems += ['kesch:pn']
+        self.valid_systems += ['kesch:pn', 'arolla:pn', 'tsa:pn']
         self.sourcepath += '_serial.' + lang
         self.descr += ' Serial ' + linkage.capitalize()
         self.prgenv_flags = {
@@ -135,7 +135,10 @@ def __init__(self, lang, linkage):
             self.valid_prog_environs += ['PrgEnv-cray-nompi',
                                          'PrgEnv-pgi-nompi',
                                          'PrgEnv-gnu-nompi']
-
+        elif (self.current_system.name in ['arolla', 'tsa'] and
+              linkage == 'dynamic'):
+            self.valid_prog_environs += ['PrgEnv-pgi-nompi',
+                                         'PrgEnv-gnu-nompi']
 
 @rfm.required_version('>=2.14')
 @rfm.parameterized_test(*([lang, linkage]
@@ -144,7 +147,7 @@ def __init__(self, lang, linkage):
 class HelloWorldTestOpenMP(HelloWorldBaseTest):
     def __init__(self, lang, linkage):
         super().__init__('openmp', lang, linkage)
-        self.valid_systems += ['kesch:pn']
+        self.valid_systems += ['kesch:pn', 'arolla:pn', 'tsa:pn']
         self.sourcepath += '_openmp.' + lang
         self.descr += ' OpenMP ' + str.capitalize(linkage)
         self.prgenv_flags = {
@@ -164,6 +167,10 @@ def __init__(self, lang, linkage):
             self.valid_prog_environs += ['PrgEnv-cray-nompi',
                                          'PrgEnv-pgi-nompi',
                                          'PrgEnv-gnu-nompi']
+        elif (self.current_system.name in ['arolla', 'tsa'] and
+              linkage == 'dynamic'):
+            self.valid_prog_environs += ['PrgEnv-pgi-nompi',
+                                         'PrgEnv-gnu-nompi']
 
         # On SLURM there is no need to set OMP_NUM_THREADS if one defines
         # num_cpus_per_task, but adding for completeness and portability
diff --git a/cscs-checks/prgenv/mpi.py b/cscs-checks/prgenv/mpi.py
index ae04401402..3460fdfff1 100644
--- a/cscs-checks/prgenv/mpi.py
+++ b/cscs-checks/prgenv/mpi.py
@@ -29,7 +29,6 @@ class MpiInitTest(rfm.RegressionTest):
     '''
 
     def __init__(self, required_thread):
-        super().__init__()
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
                               'tiger:gpu']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
@@ -68,14 +67,16 @@ def __init__(self, required_thread):
 @rfm.simple_test
 class MpiHelloTest(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'kesch:pn', 'tiger:gpu']
+                              'kesch:cn', 'kesch:pn', 'tiger:gpu',
+                              'arolla:cn', 'arolla:pn', 'tsa:cn', 'tsa:pn']
         self.valid_prog_environs = ['PrgEnv-cray']
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
-            self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu',
-                                        'PrgEnv-intel']
+            self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu']
 
         self.descr = 'MPI Hello World'
         self.sourcepath = 'mpi_helloworld.c'
diff --git a/cscs-checks/prgenv/openacc_checks.py b/cscs-checks/prgenv/openacc_checks.py
index 09f86a2777..1890243daa 100644
--- a/cscs-checks/prgenv/openacc_checks.py
+++ b/cscs-checks/prgenv/openacc_checks.py
@@ -11,13 +11,16 @@ def __init__(self, variant):
         else:
             self.num_tasks = 2
 
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-pgi']
         if self.num_tasks == 1:
             self.sourcepath = 'vecAdd_openacc.f90'
             if self.current_system.name == 'kesch':
                 self.valid_prog_environs = ['PrgEnv-cray-nompi',
                                             'PrgEnv-pgi-nompi']
+            elif self.current_system.name == 'tsa':
+                self.valid_prog_environs = ['PrgEnv-pgi-nompi']
         else:
             self.sourcepath = 'vecAdd_openacc_mpi.f90'
 
@@ -29,6 +32,12 @@ def __init__(self, variant):
                 'CRAY_ACCEL_TARGET': 'nvidia35',
                 'MV2_USE_CUDA': '1'
             }
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.variables = {
+                'CRAY_ACCEL_TARGET': 'nvidia70',
+                'MV2_USE_CUDA': '1'
+            }
 
         self.executable = self.name
         self.build_system = 'SingleSource'
@@ -47,7 +56,9 @@ def setup(self, partition, environ, **job_opts):
         elif environ.name.startswith('PrgEnv-pgi'):
             if self.current_system.name in ['daint', 'dom', 'tiger']:
                 self.build_system.fflags = ['-acc', '-ta=tesla:cc60']
-            else:
+            elif self.current_system.name == 'kesch':
                 self.build_system.fflags = ['-acc', '-ta=tesla:cc35']
+            elif self.current_system.name in ['arolla', 'tsa']:
+                self.build_system.fflags = ['-acc', '-ta=tesla:cc70']
 
         super().setup(partition, environ, **job_opts)
diff --git a/cscs-checks/system/slurm/slurm.py b/cscs-checks/system/slurm/slurm.py
index 17093f63fb..f7832c1a1e 100644
--- a/cscs-checks/system/slurm/slurm.py
+++ b/cscs-checks/system/slurm/slurm.py
@@ -8,12 +8,14 @@ class SlurmSimpleBaseCheck(rfm.RunOnlyRegressionTest):
     def __init__(self):
         self.valid_systems = ['daint:gpu', 'daint:mc',
                               'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'kesch:pn']
-        self.valid_prog_environs = ['PrgEnv-cray']
+                              'kesch:cn', 'kesch:pn',
+                              'arolla:cn', 'arolla:pn',
+                              'tsa:cn', 'tsa:pn']
+        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
         self.tags = {'slurm', 'maintenance', 'ops',
                      'production', 'single-node'}
         self.num_tasks_per_node = 1
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.exclusive_access = True
 
         self.maintainers = ['RS', 'VH']
@@ -25,12 +27,14 @@ class SlurmCompiledBaseCheck(rfm.RegressionTest):
     def __init__(self):
         self.valid_systems = ['daint:gpu', 'daint:mc',
                               'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'kesch:pn']
-        self.valid_prog_environs = ['PrgEnv-cray']
+                              'kesch:cn', 'kesch:pn',
+                              'arolla:cn', 'arolla:pn',
+                              'tsa:cn', 'tsa:pn']
+        self.valid_prog_environs = ['PrgEnv-cray', 'PrgEnv-gnu']
         self.tags = {'slurm', 'maintenance', 'ops',
                      'production', 'single-node'}
         self.num_tasks_per_node = 1
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.exclusive_access = True
 
         self.maintainers = ['RS', 'VH']
@@ -42,6 +46,10 @@ def __init__(self):
         super().__init__()
         self.executable = '/bin/hostname'
         self.hostname_patt = {
+            'arolla:cn': r'^arolla-cn\d{3}$',
+            'arolla:pn': r'^arolla-pp\d{3}$',
+            'tsa:cn': r'^tsa-cn\d{3}$',
+            'tsa:pn': r'^tsa-pp\d{3}$',
             'kesch:cn': r'^keschcn-\d{4}$',
             'kesch:pn': r'^keschpn-\d{4}$',
             'daint:gpu': r'^nid\d{5}$',
@@ -66,7 +74,9 @@ def __init__(self):
         self.num_tasks = 2
         self.valid_systems = ['daint:gpu', 'daint:mc',
                               'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'kesch:pn']
+                              'kesch:cn', 'kesch:pn',
+                              'arolla:cn', 'arolla:pn',
+                              'tsa:cn', 'tsa:pn']
         self.executable = '/bin/echo'
         self.executable_opts = ['$MY_VAR']
         self.variables = {'MY_VAR': 'TEST123456!'}
@@ -108,7 +118,9 @@ def set_memory_limit(self):
 class DefaultRequestGPU(SlurmSimpleBaseCheck):
     def __init__(self):
         super().__init__()
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn']
+        self.valid_systems = ['daint:gpu', 'dom:gpu',
+                              'arolla:cn', 'kesch:cn',
+                              'tsa:cn']
         self.executable = 'nvidia-smi'
         self.sanity_patterns = sn.assert_found(
             r'NVIDIA-SMI.*Driver Version.*', self.stdout)
diff --git a/cscs-checks/tools/io/cdo.py b/cscs-checks/tools/io/cdo.py
index 31ae46496c..207ed5d25b 100644
--- a/cscs-checks/tools/io/cdo.py
+++ b/cscs-checks/tools/io/cdo.py
@@ -30,11 +30,15 @@ def __init__(self):
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'CDO-NCO')
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'kesch:pn']
+                              'kesch:pn', 'arolla:pn', 'tsa:pn']
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-gnu-nompi']
             self.modules = ['cdo']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.valid_prog_environs = ['PrgEnv-gnu-nompi']
+            self.modules = ['cdo', 'netcdf-fortran']
         else:
             self.valid_prog_environs = ['PrgEnv-gnu']
             self.modules = ['CDO']
@@ -87,7 +91,11 @@ def __init__(self):
             r'(?i)error|conflict|unsupported|failure', self.stderr)
 
     def setup(self, partition, environ, **job_opts):
-        nco_name = 'nco' if self.current_system.name == 'kesch' else 'NCO'
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
+            nco_name = 'nco'
+        else:
+            nco_name = 'NCO'
+
         self.pre_run = ['module load %s' % nco_name]
         super().setup(partition, environ, **job_opts)
 
@@ -102,8 +110,8 @@ def __init__(self):
         # TODO: Add here also Warning? then it fails currently...
         self.sanity_patterns = sn.all([
             sn.assert_not_found(r'(?i)unsupported|error', self.stderr),
-            sn.assert_found(r'cdo info: Processed 688128 values from 5 '
-                            r'variables over 1 timestep', self.stderr)
+            sn.assert_found(r'info: Processed 5 variables over 1 timestep',
+                            self.stderr)
         ])
 
 
@@ -118,8 +126,8 @@ def __init__(self):
         # TODO: fails currently with the file test_hgroups.nc4
         self.sanity_patterns = sn.all([
             sn.assert_not_found(r'(?i)unsupported|error', self.stderr),
-            sn.assert_found(r'cdo info: Processed 442368 values from 3 '
-                            r'variables over 8 timesteps', self.stderr)
+            sn.assert_found(r'info: Processed 3 variables over 8 timestep', 
+                            self.stderr)
         ])
 
 
@@ -133,8 +141,8 @@ def __init__(self):
             'info', 'test_echam_spectral-deflated_wind10_wl_ws.nc4c']
         self.sanity_patterns = sn.all([
             sn.assert_not_found(r'(?i)unsupported|error', self.stderr),
-            sn.assert_found(r'cdo info: Processed 442368 values from 3 '
-                            r'variables over 8 timesteps', self.stderr)
+            sn.assert_found(r'info: Processed 3 variables over 8 timestep',
+                            self.stderr)
         ])
 
 
@@ -153,8 +161,8 @@ def __init__(self):
         ]
         self.sanity_patterns = sn.all([
             sn.assert_not_found(r'(?i)unsupported|error', self.stderr),
-            sn.assert_found(r'cdo merge: Processed 98304 values from 3 '
-                            r'variables over (1|3) timesteps?', self.stderr)
+            sn.assert_found(r'merge: Processed 3 variables over 3 timesteps?',
+                            self.stderr)
         ])
 
 
@@ -173,8 +181,8 @@ def __init__(self):
         ]
         self.sanity_patterns = sn.all([
             sn.assert_not_found(r'(?i)unsupported|error', self.stderr),
-            sn.assert_found(r'cdo merge: Processed 442368 values from 3 '
-                            r'variables over (8|24) timesteps', self.stderr)
+            sn.assert_found(r'merge: Processed 3 variables over 24 timesteps?',
+                            self.stderr)
         ])
 
 
@@ -194,6 +202,6 @@ def __init__(self):
         ]
         self.sanity_patterns = sn.all([
             sn.assert_not_found(r'(?i)unsupported|error', self.stderr),
-            sn.assert_found(r'cdo merge: Processed 442368 values from 3 '
-                            r'variables over (8|24) timesteps', self.stderr)
-        ])
+            sn.assert_found(r'merge: Processed 3 variables over 24 timesteps?',
+                            self.stderr)
+        ])
\ No newline at end of file
diff --git a/cscs-checks/tools/io/nco.py b/cscs-checks/tools/io/nco.py
index 69c9269950..a1c26a9921 100644
--- a/cscs-checks/tools/io/nco.py
+++ b/cscs-checks/tools/io/nco.py
@@ -23,8 +23,8 @@ def __init__(self):
         self.sourcesdir = os.path.join(self.current_system.resourcesdir,
                                        'CDO-NCO')
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'kesch:pn']
-        if self.current_system.name == 'kesch':
+                              'kesch:pn', 'arolla:pn', 'tsa:pn']
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.exclusive_access = True
             self.valid_prog_environs = ['PrgEnv-gnu-nompi']
             self.modules = ['nco']
@@ -84,7 +84,11 @@ def __init__(self):
             r'(?i)error|conflict|unsupported|failure', self.stderr)
 
     def setup(self, partition, environ, **job_opts):
-        cdo_name = 'cdo' if self.current_system.name == 'kesch' else 'CDO'
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
+            cdo_name = 'cdo'
+        else:
+            cdo_name = 'CDO'
+
         self.pre_run = ['module load %s' % cdo_name]
         super().setup(partition, environ, **job_opts)
 
diff --git a/cscs-checks/tools/profiling_and_debugging/cuda_gdb.py b/cscs-checks/tools/profiling_and_debugging/cuda_gdb.py
index c764f88f55..a26aacd99f 100644
--- a/cscs-checks/tools/profiling_and_debugging/cuda_gdb.py
+++ b/cscs-checks/tools/profiling_and_debugging/cuda_gdb.py
@@ -8,9 +8,9 @@
 @rfm.simple_test
 class CudaGdbCheck(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.valid_prog_environs = ['PrgEnv-gnu']
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.num_gpus_per_node = 1
         self.num_tasks_per_node = 1
         self.sourcesdir = 'src/Cuda'
@@ -21,21 +21,28 @@ def __init__(self):
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.modules = ['cudatoolkit/8.0.61']
+            nvidia_sm = '37'
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.modules = ['cuda/10.1.243']
+            nvidia_sm = '70'
         else:
             self.modules = ['craype-accel-nvidia60']
+            nvidia_sm = '60'
 
         self.build_system = 'Make'
         self.build_system.makefile = 'Makefile_cuda_gdb'
         self.build_system.cflags = ['-g', '-D_CSCS_ITMAX=1', '-DUSE_MPI',
                                     '-fopenmp']
-        nvidia_sm = '37' if self.current_system.name == 'kesch' else '60'
         self.build_system.cxxflags = ['-g', '-G', '-arch=sm_%s' % nvidia_sm]
         self.build_system.ldflags = ['-g', '-fopenmp', '-lstdc++']
 
-        # FIXME: workaround until the kesch programming environment is fixed
         if self.current_system.name == 'kesch':
             self.build_system.ldflags = ['-g', '-fopenmp', '-lcublas',
                                          '-lcudart', '-lm']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.build_system.ldflags += ['-L$EBROOTCUDA/lib64',
+                                          '-lcudart', '-lm']
 
         self.sanity_patterns = sn.all([
             sn.assert_found(r'^Breakpoint 1 at .*: file ', self.stdout),
diff --git a/cscs-checks/tools/profiling_and_debugging/ddt.py b/cscs-checks/tools/profiling_and_debugging/ddt.py
index 650fdc1b7d..6cf4ed40fe 100644
--- a/cscs-checks/tools/profiling_and_debugging/ddt.py
+++ b/cscs-checks/tools/profiling_and_debugging/ddt.py
@@ -27,12 +27,9 @@ def __init__(self, lang, extension):
             self.modules = ['ddt']
 
         self.prgenv_flags = {
-            # 'PrgEnv-cray': ' -O2 -homp',
             'PrgEnv-gnu': ['-g', '-O2', '-fopenmp'],
-            # 'PrgEnv-intel': ' -O2 -qopenmp',
-            # 'PrgEnv-pgi': ' -O2 -mp'
         }
-        if self.current_system.name == 'kesch':
+        if self.current_system.name in ['arolla', 'kesch', 'tsa']:
             self.exclusive_access = True
 
         self.num_tasks = 1
@@ -70,9 +67,9 @@ class DdtCpuCheck(DdtCheck):
     def __init__(self, lang, extension):
         super().__init__(lang, extension)
         self.valid_systems = ['daint:gpu', 'daint:mc', 'dom:gpu', 'dom:mc',
-                              'kesch:cn', 'tiger:gpu']
-
-        if self.current_system.name == 'kesch' and self.lang == 'C':
+                              'kesch:cn', 'tiger:gpu', 'arolla:cn', 'tsa:cn']
+        if (self.current_system.name in ['arolla', 'kesch', 'tsa']
+                and self.lang == 'C'):
             self.build_system.ldflags = ['-lm']
 
         residual_pattern = '_jacobi.%s:%d,residual'
@@ -98,14 +95,17 @@ def __init__(self, lang, extension):
 class DdtGpuCheck(DdtCheck):
     def __init__(self, lang, extension):
         super().__init__(lang, extension)
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.num_gpus_per_node = 1
         self.num_tasks_per_node = 1
         self.system_modules = {
+            'arolla': ['cuda/10.1.243'],
             'daint': ['craype-accel-nvidia60'],
             'dom': ['craype-accel-nvidia60'],
             'kesch': ['cudatoolkit/8.0.61'],
             'tiger': ['craype-accel-nvidia60'],
+            'tsa': ['cuda/10.1.243']
         }
         sysname = self.current_system.name
         self.modules += self.system_modules.get(sysname, [])
@@ -113,6 +113,8 @@ def __init__(self, lang, extension):
         # as long as cuda/9 will not be the default, we will need:
         if sysname in {'daint', 'kesch'}:
             self.variables = {'ALLINEA_FORCE_CUDA_VERSION': '8.0'}
+        elif sysname in {'arolla', 'tsa'}:
+            self.variables = {'ALLINEA_FORCE_CUDA_VERSION': '10.1'}
 
         self.ddt_options = [
             '--offline --output=ddtreport.txt ',
@@ -123,6 +125,11 @@ def __init__(self, lang, extension):
         if self.current_system.name == 'kesch':
             arch = 'sm_37'
             self.build_system.ldflags = ['-lm', '-lcudart']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            arch = 'sm_70'
+            self.build_system.ldflags = ['-lstdc++', '-lm',
+                                         '-L$EBROOTCUDA/lib64',
+                                         '-lcudart']
         else:
             arch = 'sm_60'
             self.build_system.ldflags = ['-lstdc++']
diff --git a/cscs-checks/tools/profiling_and_debugging/nvprof.py b/cscs-checks/tools/profiling_and_debugging/nvprof.py
index 8d5946408a..7fbb002561 100644
--- a/cscs-checks/tools/profiling_and_debugging/nvprof.py
+++ b/cscs-checks/tools/profiling_and_debugging/nvprof.py
@@ -6,9 +6,9 @@
 @rfm.simple_test
 class NvprofCheck(rfm.RegressionTest):
     def __init__(self):
-        super().__init__()
         self.descr = 'Checks the nvprof tool'
-        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu']
+        self.valid_systems = ['daint:gpu', 'dom:gpu', 'kesch:cn', 'tiger:gpu',
+                              'arolla:cn', 'tsa:cn']
         self.valid_prog_environs = ['PrgEnv-gnu']
         self.num_gpus_per_node = 1
         self.num_tasks_per_node = 1
@@ -32,12 +32,16 @@ def __init__(self):
         self.build_system.cxxflags = ['-g', '-G']
         self.build_system.ldflags = ['-g', '-fopenmp', '-std=c99', '-lstdc++']
 
-        # FIXME temporary workaround
-        # the programming environment should be adapted / fixed
         if self.current_system.name == 'kesch':
             self.exclusive_access = True
             self.modules = ['cudatoolkit/8.0.61']
             self.build_system.ldflags += ['-lcudart', '-lm']
+        elif self.current_system.name in ['arolla', 'tsa']:
+            self.exclusive_access = True
+            self.modules = ['cuda/10.1.243']
+            self.build_system.ldflags = ['-lstdc++', '-lm',
+                                         '-L$EBROOTCUDA/lib64',
+                                         '-lcudart']
         else:
             self.modules = ['craype-accel-nvidia60']