diff --git a/verif/conformance/tosa_base_profile_ops_info.json b/verif/conformance/tosa_base_profile_ops_info.json
index e40ddfc..b8b80ab 100644
--- a/verif/conformance/tosa_base_profile_ops_info.json
+++ b/verif/conformance/tosa_base_profile_ops_info.json
@@ -297,6 +297,20 @@
                         "--allow-pooling-and-conv-oversizes"
                     ]
                 ]
+            },
+            "8k_level": {
+                "no_negative_tests": "true",
+                "selector": "8k_level",
+                "generator_args": [
+                    [
+                        "--target-dtype",
+                        "int8",
+                        "--target-dtype",
+                        "int16",
+                        "--tensor-dim-range",
+                        "3,10",
+                        "--level-8k-sizes"                    ]
+                ]
             }
         },
         "selection": {
@@ -316,6 +330,9 @@
                     "type",
                     "pad"
                 ]
+            },
+            "8k_level": {
+                "all": "true"
             }
         }
     },
@@ -1079,6 +1096,21 @@
                         "--allow-pooling-and-conv-oversizes"
                     ]
                 ]
+            },
+            "8k_level": {
+                "no_negative_tests": "true",
+                "selector": "8k_level",
+                "generator_args": [
+                    [
+                        "--target-dtype",
+                        "int8",
+                        "--target-dtype",
+                        "int16",
+                        "--tensor-dim-range",
+                        "2,5",
+                        "--level-8k-sizes"
+                    ]
+                ]
             }
         },
         "selection": {
@@ -1101,6 +1133,9 @@
                     "type",
                     "pad"
                 ]
+            },
+            "8k_level": {
+                "all": "true"
             }
         }
     },
@@ -1140,6 +1175,21 @@
                         "--allow-pooling-and-conv-oversizes"
                     ]
                 ]
+            },
+            "8k_level": {
+                "no_negative_tests": "true",
+                "selector": "8k_level",
+                "generator_args": [
+                    [
+                        "--target-dtype",
+                        "int8",
+                        "--target-dtype",
+                        "int16",
+                        "--tensor-dim-range",
+                        "2,5",
+                        "--level-8k-sizes"
+                    ]
+                ]
             }
         },
         "selection": {
@@ -1163,6 +1213,9 @@
                     "pad",
                     "stride"
                 ]
+            },
+            "8k_level": {
+                "all": "true"
             }
         }
     },
@@ -1202,6 +1255,21 @@
                         "--allow-pooling-and-conv-oversizes"
                     ]
                 ]
+            },
+            "8k_level": {
+                "no_negative_tests": "true",
+                "selector": "8k_level",
+                "generator_args": [
+                    [
+                        "--target-dtype",
+                        "int8",
+                        "--target-dtype",
+                        "int16",
+                        "--tensor-dim-range",
+                        "2,5",
+                        "--level-8k-sizes"
+                    ]
+                ]
             }
         },
         "selection": {
@@ -1224,6 +1292,9 @@
                     "type",
                     "pad"
                 ]
+            },
+            "8k_level": {
+                "all": "true"
             }
         }
     },
@@ -2207,6 +2278,21 @@
                         "--allow-pooling-and-conv-oversizes"
                     ]
                 ]
+            },
+            "8k_level": {
+                "no_negative_tests": "true",
+                "selector": "8k_level",
+                "generator_args": [
+                    [
+                        "--target-dtype",
+                        "int8",
+                        "--target-dtype",
+                        "int16",
+                        "--tensor-dim-range",
+                        "3,10",
+                        "--level-8k-sizes"
+                    ]
+                ]
             }
         },
         "selection": {
@@ -2226,6 +2312,9 @@
                     "type",
                     "pad"
                 ]
+            },
+            "8k_level": {
+                "all": "true"
             }
         }
     },
@@ -3588,6 +3677,21 @@
                         "1"
                     ]
                 ]
+            },
+            "8k_level": {
+                "no_negative_tests": "true",
+                "selector": "8k_level",
+                "generator_args": [
+                    [
+                        "--target-dtype",
+                        "int8",
+                        "--target-dtype",
+                        "int16",
+                        "--tensor-dim-range",
+                        "2,5",
+                        "--level-8k-sizes"
+                    ]
+                ]
             }
         },
         "selection": {
@@ -3610,6 +3714,9 @@
                     "stride",
                     "pad"
                 ]
+            },
+            "8k_level": {
+                "all": "true"
             }
         }
     },
diff --git a/verif/conformance/tosa_verif_conformance_generator.py b/verif/conformance/tosa_verif_conformance_generator.py
index 2d9dad3..ef6bfb9 100644
--- a/verif/conformance/tosa_verif_conformance_generator.py
+++ b/verif/conformance/tosa_verif_conformance_generator.py
@@ -755,7 +755,29 @@
                             gen_neg_dim_range,
                         )
 
-                        if args.convert_all_tests:
+                        # Work out which selection criteria we are using
+                        if "selector" in gen_dict:
+                            selector_name = gen_dict["selector"]
+                            if selector_name not in test_params[op]["selection"]:
+                                logger.warn(
+                                    f"Could not find {selector_name} in selection dict for {op} - using default"
+                                )
+                                selector_name = "default"
+                        else:
+                            selector_name = "default"
+                        if selector_name not in test_params[op]["selection"]:
+                            logger.error(
+                                f"Could not find {selector_name} in selection dict for {op}"
+                            )
+                            raise (GenConformanceError())
+
+                        # Selection criteria
+                        selection_config = test_params[op]["selection"][selector_name]
+
+                        if args.convert_all_tests or (
+                            "all" in selection_config
+                            and selection_config["all"] == "true"
+                        ):
                             logger.debug(f"Running and converting all {op} tests")
                             generate_results(args, profile, op, op_build_dir)
                             operator_test_list = None
@@ -763,26 +785,6 @@
                             logger.debug(
                                 f"Running and converting selection of {op} tests"
                             )
-                            # Work out which selection criteria we are using
-                            if "selector" in gen_dict:
-                                selector_name = gen_dict["selector"]
-                                if selector_name not in test_params[op]["selection"]:
-                                    logger.warn(
-                                        f"Could not find {selector_name} in selection dict for {op} - using default"
-                                    )
-                                    selector_name = "default"
-                            else:
-                                selector_name = "default"
-                            if selector_name not in test_params[op]["selection"]:
-                                logger.error(
-                                    f"Could not find {selector_name} in selection dict for {op}"
-                                )
-                                raise (GenConformanceError())
-
-                            # Selection criteria
-                            selection_config = test_params[op]["selection"][
-                                selector_name
-                            ]
                             if test_type in ["positive", "both"]:
                                 tests_gen, tests_gen2 = tee(
                                     get_op_tests_selection(
diff --git a/verif/generator/tosa_arg_gen.py b/verif/generator/tosa_arg_gen.py
index b027d34..2bbc349 100644
--- a/verif/generator/tosa_arg_gen.py
+++ b/verif/generator/tosa_arg_gen.py
@@ -1056,66 +1056,129 @@
 
     @staticmethod
     def agConv(testGen, opName, shapeList, dtypes, error_name=None):
+        # Used by CONV2D, CONV3D and DEPTHWISE_CONV2D
         arg_list = []
 
+        if testGen.args.level8k and error_name is not None:
+            # Don't produce negative large tests
+            return arg_list
+
+        # Shape: Batches, (Depth), Height, Width, Channels
         ifm_shape = shapeList[0]
+        # Shape: (OFM channels), (KD), KH, KW, IFM channels
         filter_shape = shapeList[1]
-        # determine the kernel shape from operator name (e.g. "conv2d_3x3" => [3,3])
-        k = [int(x) for x in opName.split("_")[-1].split("x")]
 
         accum_dtype = get_accum_dtype_from_tgTypes(dtypes)
 
         # Check the rank
-        rank = 5 if opName.startswith("conv3d") else 4
+        conv3d = opName.startswith("conv3d")
+        rank = 5 if conv3d else 4
         if error_name != ErrorIf.WrongRank:
             assert len(ifm_shape) == rank
             assert len(filter_shape) == rank
 
-        # kernel rank omits batch and channels
+        # kernel rank omits channels
         k_rank = rank - 2
-        assert len(k) == k_rank
+        k_pos = 0 if opName.startswith("depthwise") else 1
+        k_shape = tuple(filter_shape[k_pos : (k_pos + k_rank)])
 
-        # Generate comprehensive argument lists
-        # - except for named errors, which use specific invalid value(s)
-        if error_name == ErrorIf.PadSmallerZero:
-            p_vals = [testGen.rng.choice(range(-5, 0))]
-        else:
-            p_vals = [x for x in range(0, testGen.args.max_conv_padding + 1)]
-        paddings = {x for x in itertools.product(*([p_vals] * k_rank * 2))}
-        if error_name == ErrorIf.StrideSmallerOne:
-            # Can't use stride=0, as it is used to derive output shape, as a divisor
-            s_vals = [testGen.rng.choice(range(-5, 0))]
-        else:
-            # Stride must be greater than 1 to force non-integer error
-            startStride = 1 if error_name != ErrorIf.ConvOutputShapeNonInteger else 2
-            s_vals = [x for x in range(startStride, testGen.args.max_conv_stride + 1)]
-        strides = {x for x in itertools.product(*([s_vals] * k_rank))}
-        if error_name == ErrorIf.DilationSmallerOne:
-            d_vals = [testGen.rng.choice(range(-5, 1))]
-        else:
-            d_vals = [x for x in range(1, testGen.args.max_conv_dilation + 1)]
-        dilations = {x for x in itertools.product(*([d_vals] * k_rank))}
-
-        if not error_name and testGen.args.oversize:
-            # add some oversize argument values
-            if max(ifm_shape) < 64:
-                bigPadding = 9
-                paddings.update(
-                    {x for x in itertools.product(*([[0, bigPadding]] * (k_rank * 2)))}
+        if not testGen.args.level8k:
+            # Generate comprehensive argument lists
+            # - except for named errors, which use specific invalid value(s)
+            if error_name == ErrorIf.PadSmallerZero:
+                p_vals = [testGen.rng.choice(range(-5, 0))]
+            else:
+                p_vals = [x for x in range(0, testGen.args.max_conv_padding + 1)]
+            paddings = {x for x in itertools.product(*([p_vals] * k_rank * 2))}
+            if error_name == ErrorIf.StrideSmallerOne:
+                # Can't use stride=0, as it is used to derive output shape, as a divisor
+                s_vals = [testGen.rng.choice(range(-5, 0))]
+            else:
+                # Stride must be greater than 1 to force non-integer error
+                startStride = (
+                    1 if error_name != ErrorIf.ConvOutputShapeNonInteger else 2
                 )
-            bigStride = 8
-            strides.update({x for x in itertools.product(*([[1, bigStride]] * k_rank))})
-            bigDilation = 7
-            dilations.update(
-                {x for x in itertools.product(*([[1, bigDilation]] * k_rank))}
-            )
+                s_vals = [
+                    x for x in range(startStride, testGen.args.max_conv_stride + 1)
+                ]
+            strides = {x for x in itertools.product(*([s_vals] * k_rank))}
+            if error_name == ErrorIf.DilationSmallerOne:
+                d_vals = [testGen.rng.choice(range(-5, 1))]
+            else:
+                d_vals = [x for x in range(1, testGen.args.max_conv_dilation + 1)]
+            dilations = {x for x in itertools.product(*([d_vals] * k_rank))}
 
-        # There are too many parameter combinations, so generate them sparsely,
-        # very sparse for negative tests
-        sparsity_factor = 2 if error_name else 120
-        sparsity = TosaArgGen._calculate_sparsity(
-            len(paddings) * len(strides) * len(dilations), sparsity_factor
-        )
+            if not error_name and testGen.args.oversize:
+                # add some oversize argument values
+                if max(ifm_shape) < 64:
+                    bigPadding = 9
+                    paddings.update(
+                        {
+                            x
+                            for x in itertools.product(
+                                *([[0, bigPadding]] * (k_rank * 2))
+                            )
+                        }
+                    )
+                bigStride = 8
+                strides.update(
+                    {x for x in itertools.product(*([[1, bigStride]] * k_rank))}
+                )
+                bigDilation = 7
+                dilations.update(
+                    {x for x in itertools.product(*([[1, bigDilation]] * k_rank))}
+                )
+            max_dim_size = None
+
+            # There are too many parameter combinations, so generate them sparsely,
+            # very sparse for negative tests
+            sparsity_factor = 2 if error_name else 120
+            sparsity = TosaArgGen._calculate_sparsity(
+                len(paddings) * len(strides) * len(dilations), sparsity_factor
+            )
+        else:
+            # Only test 8k levels boundaries
+            bigStride = testGen.TOSA_8K_LEVEL_MAX_STRIDE
+            bigKernel = testGen.TOSA_8K_LEVEL_MAX_KERNEL
+            bigPadding = bigKernel
+
+            dilation_shape = [1] * k_rank
+            pad_shape = [0] * k_rank * 2
+            if conv3d:
+                # Small stride apart from for big kernel (see below) to keep
+                # tensor size/calculation small
+                stride_shape = [1] * k_rank
+                for idx in range(k_rank):
+                    pad_offset = idx * 2
+                    if k_shape[idx] == bigKernel:
+                        # Padding shape needs to account for tensor shape
+                        pad_shape[pad_offset] = bigPadding - ifm_shape[idx + 1]
+                        pad_shape[pad_offset + 1] = bigPadding - dilation_shape[idx] + 1
+                        # Big stride to reduce output size
+                        stride_shape[idx] = bigKernel
+                    else:
+                        # Account for kernel size
+                        pad_shape[pad_offset] = k_shape[idx] - 1
+            else:
+                # Always have a large stride with extra padding and dilation to keep
+                # tensor calculation reasonable
+                stride_shape = [bigKernel] * k_rank
+                for idx in range(k_rank):
+                    # Dilation shape must account for kernel size
+                    dilation_shape[idx] = bigKernel // k_shape[idx]
+                    # Padding shape needs to accommodate tensor/kernel & dilation
+                    pad_offset = idx * 2
+                    pad_shape[pad_offset] = bigPadding - ifm_shape[idx + 1]
+                    pad_shape[pad_offset + 1] = bigPadding - dilation_shape[idx] + 1
+
+            strides = {tuple(stride_shape)}
+            dilations = {tuple(dilation_shape)}
+            paddings = {tuple(pad_shape)}
+            # Create a limit for the output dimensions size
+            max_dim_size = testGen.TOSA_8K_LEVEL_MAX_KERNEL
+
+            # Currently allow all combinations that are reasonable size
+            sparsity = 1
 
         n = 0
         for s in sorted(list(strides)):
@@ -1125,26 +1188,30 @@
                         n % sparsity == 0
                         # the padded shape must exceed the dilation * kernel to get a positive
                         # sized output shape
-                        and (ifm_shape[1] - 1 + p[0] + p[1]) > d[0] * (k[0] - 1)
-                        and (ifm_shape[2] - 1 + p[2] + p[3]) > d[1] * (k[1] - 1)
+                        and (ifm_shape[1] - 1 + p[0] + p[1]) > d[0] * (k_shape[0] - 1)
+                        and (ifm_shape[2] - 1 + p[2] + p[3]) > d[1] * (k_shape[1] - 1)
                         and (
                             k_rank < 3
-                            or ((ifm_shape[3] - 1 + p[4] + p[5]) > d[2] * (k[2] - 1))
+                            or (
+                                (ifm_shape[3] - 1 + p[4] + p[5])
+                                > d[2] * (k_shape[2] - 1)
+                            )
                         )
                     ):
                         remainders = []
+                        outputs = []
                         for index in range(k_rank):
                             pad_offset = index * 2
-                            remainders.append(
-                                (
-                                    ifm_shape[index + 1]
-                                    - 1
-                                    + p[pad_offset]
-                                    + p[pad_offset + 1]
-                                    - (k[index] - 1) * d[index]
-                                )
-                                % s[index]
+                            partial = (
+                                ifm_shape[index + 1]
+                                - 1
+                                + p[pad_offset]
+                                + p[pad_offset + 1]
+                                - (k_shape[index] - 1) * d[index]
                             )
+                            remainders.append(partial % s[index])
+                            outputs.append((partial // s[index]) + 1)
+
                         if (
                             # the parameters must produce integer exact output
                             error_name != ErrorIf.ConvOutputShapeNonInteger
@@ -1153,13 +1220,22 @@
                             error_name == ErrorIf.ConvOutputShapeNonInteger
                             and max(remainders) > 0
                         ):
+                            if (
+                                max_dim_size is not None
+                                and max(outputs) >= max_dim_size
+                            ):
+                                # Test will consume too much memory - skip it
+                                continue
+
+                            # Support for larger values than 9 needs different delimiter
+                            delim = "" if max(s + p + d) <= 9 else "x"
                             arg_list.append(
                                 (
                                     "acc{}_st{}_pad{}_dilat{}".format(
                                         testGen.typeStr(accum_dtype),
-                                        "".join([str(x) for x in s]),
-                                        "".join([str(x) for x in p]),
-                                        "".join([str(x) for x in d]),
+                                        delim.join([str(x) for x in s]),
+                                        delim.join([str(x) for x in p]),
+                                        delim.join([str(x) for x in d]),
                                     ),
                                     [accum_dtype, s, p, d],
                                 )
@@ -1215,6 +1291,10 @@
     def agTransposeConv2D(testGen, opName, shapeList, dtypes, error_name=None):
         arg_list = []
 
+        if testGen.args.level8k and error_name is not None:
+            # Don't produce negative large tests
+            return arg_list
+
         ifm_shape = shapeList[0]
         filter_shape = shapeList[1]
 
@@ -1225,66 +1305,112 @@
             assert len(ifm_shape) == 4
             assert len(filter_shape) == 4
 
-        # Generate comprehensive argument lists
-        # - except for named errors, which use specific invalid value(s)
-        smallest_padding_size = -min(filter_shape[1], filter_shape[2]) + 1
-        if error_name == ErrorIf.PadLargerEqualKernel:
-            max_filter_size = -max(filter_shape[1], filter_shape[2])
-            p_vals = [testGen.rng.choice(range(max_filter_size - 10, max_filter_size))]
-        else:
-            p_vals = [
-                x
-                for x in range(smallest_padding_size, testGen.args.max_conv_padding + 1)
-            ]
-        paddings = {x for x in itertools.product(*([p_vals] * 4))}
-        if error_name == ErrorIf.StrideSmallerOne:
-            # Can't use stride=0, as it is used to derive output shape, as a divisor
-            s_vals = [testGen.rng.choice(range(-5, 0))]
-        else:
-            s_vals = [x for x in range(1, testGen.args.max_conv_stride + 1)]
-        strides = {x for x in itertools.product(*([s_vals] * 2))}
+        k_shape = tuple(filter_shape[1:3])
 
-        if not error_name and testGen.args.oversize:
-            # add some oversize argument values
-            if max(ifm_shape) < 64:
-                bigPadding = 9
-                paddings.update(
-                    {
-                        x
-                        for x in itertools.product(
-                            *([[smallest_padding_size, bigPadding]] * 4)
-                        )
-                    }
-                )
-            bigStride = 8
-            strides.update({x for x in itertools.product(*([[1, bigStride]] * 2))})
+        if not testGen.args.level8k:
+            # Generate comprehensive argument lists
+            # - except for named errors, which use specific invalid value(s)
+            smallest_padding_size = -min(k_shape[0], k_shape[1]) + 1
+            if error_name == ErrorIf.PadLargerEqualKernel:
+                max_filter_size = -max(k_shape[0], k_shape[1])
+                p_vals = [
+                    testGen.rng.choice(range(max_filter_size - 10, max_filter_size))
+                ]
+            else:
+                p_vals = [
+                    x
+                    for x in range(
+                        smallest_padding_size, testGen.args.max_conv_padding + 1
+                    )
+                ]
+            paddings = {x for x in itertools.product(*([p_vals] * 4))}
+            if error_name == ErrorIf.StrideSmallerOne:
+                # Can't use stride=0, as it is used to derive output shape, as a divisor
+                s_vals = [testGen.rng.choice(range(-5, 0))]
+            else:
+                s_vals = [x for x in range(1, testGen.args.max_conv_stride + 1)]
+            strides = {x for x in itertools.product(*([s_vals] * 2))}
 
-        # There are too many parameter combinations, so generate them sparsely,
-        # very sparse for negative tests
-        sparsity_factor = 2 if error_name else 10
-        sparsity = len(paddings) * len(strides) // sparsity_factor + 1
-        # If there are only a small number of tests, just select them all
-        if sparsity < 13:
+            if not error_name and testGen.args.oversize:
+                # add some oversize argument values
+                if max(ifm_shape) < 64:
+                    bigPadding = 9
+                    paddings.update(
+                        {
+                            x
+                            for x in itertools.product(
+                                *([[smallest_padding_size, bigPadding]] * 4)
+                            )
+                        }
+                    )
+                bigStride = 8
+                strides.update({x for x in itertools.product(*([[1, bigStride]] * 2))})
+
+            # There are too many parameter combinations, so generate them sparsely,
+            # very sparse for negative tests
+            sparsity_factor = 2 if error_name else 10
+            sparsity = len(paddings) * len(strides) // sparsity_factor + 1
+            # If there are only a small number of tests, just select them all
+            if sparsity < 13:
+                sparsity = 1
+            # To get a variety of parameter combinations sparsity should not be a
+            # multiple of 2, 3 or 5
+            while sparsity % 2 == 0 or sparsity % 3 == 0 or sparsity % 5 == 0:
+                sparsity += 1
+        else:
+            # Only test 8k levels boundaries
+            bigStride = testGen.TOSA_8K_LEVEL_MAX_STRIDE
+            bigKernel = testGen.TOSA_8K_LEVEL_MAX_KERNEL
+            bigPadding = bigKernel
+
+            pad_shape = [0] * (len(k_shape) * 2)
+            stride_shape = [1] * len(k_shape)
+            # The point at which input dimension combined with the stride will
+            # create large output sizes!
+            LARGE_SIZE = 2
+            for idx in range(len(k_shape)):
+                pad_offset = idx * 2
+                if k_shape[idx] == bigKernel:
+                    # Set large stride
+                    stride_shape[idx] = bigKernel
+                    # Use negative output padding to reduce shape size
+                    pad_shape[pad_offset] = -(bigPadding - 1)
+                    if ifm_shape[idx + 1] > LARGE_SIZE:
+                        pad_shape[pad_offset + 1] = -(bigPadding - 1)
+                else:
+                    # The other dimension should be the bigKernel
+                    alt_idx = 1 - idx
+                    if (
+                        k_shape[alt_idx] == bigKernel
+                        and ifm_shape[alt_idx + 1] < LARGE_SIZE
+                    ):
+                        # As the input is small, the large stride won't
+                        # affect the output so we can add some padding
+                        pad_shape[pad_offset + 1] = bigPadding
+
+            strides = {tuple(stride_shape)}
+            paddings = {tuple(pad_shape)}
+
+            # Currently allow all combinations that are reasonable size
             sparsity = 1
-        # To get a variety of parameter combinations sparsity should not be a
-        # multiple of 2, 3 or 5
-        while sparsity % 2 == 0 or sparsity % 3 == 0 or sparsity % 5 == 0:
-            sparsity += 1
 
         n = 0
         for s in sorted(list(strides)):
             for p in sorted(list(paddings)):
                 if n % sparsity == 0:
                     # Determine the output shape
-                    oh = (ifm_shape[1] - 1) * s[0] + p[0] + p[1] + filter_shape[1]
-                    ow = (ifm_shape[2] - 1) * s[1] + p[2] + p[3] + filter_shape[2]
+                    oh = (ifm_shape[1] - 1) * s[0] + p[0] + p[1] + k_shape[0]
+                    ow = (ifm_shape[2] - 1) * s[1] + p[2] + p[3] + k_shape[1]
                     os = [ifm_shape[0], oh, ow, filter_shape[0]]
+
+                    # Support for larger values than 9 needs different delimiter
+                    delim = "" if max(s + p) <= 9 else "x"
                     arg_list.append(
                         (
                             "acc{}_st{}_pad{}_os{}".format(
                                 testGen.typeStr(accum_dtype),
-                                "".join([str(x) for x in s]),
-                                "".join([str(x) for x in p]),
+                                delim.join([str(x) for x in s]),
+                                delim.join([str(x) for x in p]),
                                 "x".join([str(x) for x in os]),
                             ),
                             [accum_dtype, s, p, os],
@@ -1364,15 +1490,49 @@
         if error_name != ErrorIf.WrongRank:
             assert len(shape) == 4
 
-        # Generate comprehensive argument lists
-        p_vals = [x for x in range(0, testGen.args.max_pooling_padding + 1)]
-        paddings = {x for x in itertools.product(*([p_vals] * 4))}
-        # Stride must be greater than 1 to force non-integer error
+        test_level8k = testGen.args.level8k and error_name is None
+
         startStride = 1 if error_name != ErrorIf.PoolingOutputShapeNonInteger else 2
-        s_vals = [x for x in range(startStride, testGen.args.max_pooling_stride + 1)]
-        strides = {x for x in itertools.product(*([s_vals] * 2))}
-        k_vals = [x for x in range(2, testGen.args.max_pooling_kernel + 1)]
-        kernels = {x for x in itertools.product(*([k_vals] * 2))}
+        startKernel = 2
+        startPad = 0
+        if not test_level8k:
+            # Generate comprehensive argument lists
+            p_vals = [x for x in range(startPad, testGen.args.max_pooling_padding + 1)]
+            paddings = {x for x in itertools.product(*([p_vals] * 4))}
+            # Stride must be greater than 1 to force non-integer error
+            s_vals = [
+                x for x in range(startStride, testGen.args.max_pooling_stride + 1)
+            ]
+            strides = {x for x in itertools.product(*([s_vals] * 2))}
+            k_vals = [
+                x for x in range(startKernel, testGen.args.max_pooling_kernel + 1)
+            ]
+            kernels = {x for x in itertools.product(*([k_vals] * 2))}
+            max_dim_size = None
+        else:
+            # Only test 8k levels
+            bigStride = testGen.TOSA_8K_LEVEL_MAX_STRIDE
+            bigKernel = testGen.TOSA_8K_LEVEL_MAX_KERNEL
+            strides = {(1, bigStride), (bigStride, 4)}
+            kernels = {(1, bigKernel), (bigKernel, 3)}
+            paddings = set()
+            for s in sorted(list(strides)):
+                for k in sorted(list(kernels)):
+                    padding = []
+                    for idx in range(len(k)):
+                        total_padding = s[idx] - shape[idx + 1] + k[idx]
+                        while total_padding < 0:
+                            # Must meet: shape + padding > kernel
+                            total_padding += s[idx]
+                        if total_padding < k[idx]:
+                            padding.extend([0, total_padding])
+                        else:
+                            # Note this may produce padding >= k[idx] which is not
+                            # allowed - but will be ignored in the creation loop below
+                            padding.extend([k[idx] - 1, total_padding - (k[idx] - 1)])
+                    paddings.add(tuple(padding))
+            # Create a limit for the output dimensions size
+            max_dim_size = testGen.TOSA_8K_LEVEL_MAX_KERNEL
 
         if opName == "max_pool2d":
             accum_dtypes = [None]  # max_pool has no accumulate dtype
@@ -1389,25 +1549,33 @@
             # incorrect input data-type
             accum_dtypes = [DType.INT32]
 
-        if testGen.args.oversize:
-            # add some oversize argument values
-            bigStride = 7
-            strides.update(
-                {x for x in itertools.product(*([[startStride, bigStride]] * 2))}
-            )
-            bigKernel = 9
-            kernels.update({x for x in itertools.product(*([[2, bigKernel]] * 2))})
-            if max(shape) < 64:
-                # padding must be less than the kernel size
-                bigPadding = bigKernel - 1
-                paddings.update(
-                    {x for x in itertools.product(*([[0, bigPadding]] * 4))}
+        if not test_level8k:
+            if testGen.args.oversize:
+                # add some oversize argument values
+                bigStride = 7
+                bigKernel = 9
+                strides.update(
+                    {x for x in itertools.product(*([[startStride, bigStride]] * 2))}
                 )
+                kernels.update(
+                    {x for x in itertools.product(*([[startKernel, bigKernel]] * 2))}
+                )
+                if max(shape) < 64:
+                    # padding must be less than the kernel size
+                    bigPadding = bigKernel - 1
+                    paddings.update(
+                        {x for x in itertools.product(*([[startPad, bigPadding]] * 4))}
+                    )
 
-        # There are too many parameter combinations, so generate them sparsely,
-        # very sparse for negative tests
-        sparsity_factor = 2 if error_name else 500
-        sparsity = len(paddings) * len(strides) * len(kernels) // sparsity_factor + 1
+            # There are too many parameter combinations, so generate them sparsely,
+            # very sparse for negative tests
+            sparsity_factor = 2 if error_name else 500
+            sparsity = (
+                len(paddings) * len(strides) * len(kernels) // sparsity_factor + 1
+            )
+        else:
+            # We have already limited test output combinations for 8k tests
+            sparsity = 1
 
         arg_str = (
             "acc{}_st{}_kern{}_pad{}"
@@ -1418,10 +1586,13 @@
         def get_arg_list_element(accum, stride, pad, kern):
             # Return tuple containing the formatted argument string and
             # the corresponding argument values
+
+            # Support for larger values than 9 needs different delimiter
+            delim = "" if max(stride + kern + pad) <= 9 else "x"
             arg_str_elems = [
-                "".join([str(x) for x in stride]),
-                "".join([str(x) for x in kern]),
-                "".join([str(x) for x in pad]),
+                delim.join([str(x) for x in stride]),
+                delim.join([str(x) for x in kern]),
+                delim.join([str(x) for x in pad]),
             ]
             # Note: different order to string
             arg_val_elems = [stride, pad, kern]
@@ -1459,8 +1630,13 @@
                             and (shape[1] + p[0] + p[1]) > k[0]
                             and (shape[2] + p[2] + p[3]) > k[1]
                         ):
-                            remainder_h = (shape[1] + p[0] + p[1] - k[0]) % s[0]
-                            remainder_w = (shape[2] + p[2] + p[3] - k[1]) % s[1]
+                            partial_h = shape[1] + p[0] + p[1] - k[0]
+                            partial_w = shape[2] + p[2] + p[3] - k[1]
+                            remainder_h = partial_h % s[0]
+                            remainder_w = partial_w % s[1]
+                            output_h = partial_h // s[0] + 1
+                            output_w = partial_w // s[1] + 1
+                            # debug print(shape, remainder_h, remainder_w, "/", output_h, output_w)
                             if (
                                 # the parameters must produce integer exact output
                                 error_name != ErrorIf.PoolingOutputShapeNonInteger
@@ -1470,6 +1646,12 @@
                                 error_name == ErrorIf.PoolingOutputShapeNonInteger
                                 and (remainder_h != 0 or remainder_w != 0)
                             ):
+                                if (
+                                    max_dim_size is not None
+                                    and max(output_h, output_w) > max_dim_size
+                                ):
+                                    # Test will consume too much memory - skip it
+                                    continue
                                 arg_vals = [a, s, p, k]
                                 arg_list.append(get_arg_list_element(*arg_vals))
                         n += 1
diff --git a/verif/generator/tosa_error_if.py b/verif/generator/tosa_error_if.py
index b19d5e9..8c40371 100644
--- a/verif/generator/tosa_error_if.py
+++ b/verif/generator/tosa_error_if.py
@@ -2547,14 +2547,16 @@
 
         args = kwargs["args"]
 
-        # MaxPool2D has no accum_dtype arg
-        stride_idx, pad_idx = (0, 1) if opName == "max_pool2d" else (1, 2)
+        # Skip accum_dtype arg (apart from MaxPool2D that doesn't have one)
+        stride_idx, pad_idx = (1, 2) if opName != "max_pool2d" else (0, 1)
+
+        # Common info for all ops
         strides = args[stride_idx]
         padding = args[pad_idx]
 
         if opName.endswith("pool2d"):
             # avg_pool2d, max_pool2d
-            kernel_shape = args[2]
+            kernel_shape = args[pad_idx + 1]
             h = (
                 input_shape[1] + padding[0] + padding[1] + strides[0] - kernel_shape[0]
             ) // strides[0]
@@ -2566,53 +2568,36 @@
 
         if opName.startswith("transpose_conv2d"):
             # transpose_conv2d
-            output_shape = args[2]
+            output_shape = args[pad_idx + 1]
             filter_shape = inputShapes[1]
             kernel_shape = filter_shape[1:-1]
 
             def get_out_size(in_size, stride, kernel_size, out_pad, in_pad):
-                """Calculate the transpose_conv2d output size for a dimension.
+                """Calculate the transpose_conv2d output size for a dimension."""
+                return (in_size - 1) * stride + kernel_size + in_pad + out_pad
 
-                Args:
-                    in_size: the input size - int
-                    stride: the stride - int
-                    kernel_size: the kernel size - int
-                    out_pad: the output padding - int
-                    in_pad: the input padding - int
-
-                Returns:
-                    the output size
-                """
-                return (in_size - 1) * stride + kernel_size - in_pad - out_pad
-
-            for pad_h, pad_w in (
-                (kernel_shape[0] - 1, kernel_shape[1] - 1),  # FULL padding
-                (kernel_shape[0] // 2, kernel_shape[1] // 2),  # SAME padding
-                (0, 0),  # VALID padding
-            ):
-                h = get_out_size(
-                    input_shape[1],
-                    strides[0],
-                    kernel_shape[0],
-                    padding[0],
-                    pad_h,
-                )
-                w = get_out_size(
-                    input_shape[2],
-                    strides[1],
-                    kernel_shape[1],
-                    padding[1],
-                    pad_w,
-                )
-                if output_shape[1] == h and output_shape[2] == w:
-                    return False
-
-            # output shape does not match the expected shape for any padding option
+            h = get_out_size(
+                input_shape[1],
+                strides[0],
+                kernel_shape[0],
+                padding[0],
+                padding[1],
+            )
+            w = get_out_size(
+                input_shape[2],
+                strides[1],
+                kernel_shape[1],
+                padding[2],
+                padding[3],
+            )
+            if output_shape[1] == h and output_shape[2] == w:
+                return False
+            # output shape does not match the expected shape
             return True
 
         if "conv2d" in opName or "conv3d" in opName:
             # conv2d, conv3d, depthwise_conv2d
-            dilations = args[2]
+            dilations = args[pad_idx + 1]
             filter_shape = inputShapes[1]
             kernel_shape = (
                 filter_shape[0:2]
@@ -2621,12 +2606,13 @@
             )
 
             for i in range(len(kernel_shape)):
+                pad_offset = i * 2
                 dim = (
                     input_shape[i + 1]
-                    - kernel_shape[i]
-                    - (kernel_shape[i] - 1) * (dilations[i] - 1)
-                    + padding[i * 2 + 0]
-                    + padding[i * 2 + 1]
+                    - 1
+                    + padding[pad_offset]
+                    + padding[pad_offset + 1]
+                    - (kernel_shape[i] - 1) * dilations[i]
                 ) // strides[i] + 1
                 # return True if any dimension is < 1
                 if dim < 1:
diff --git a/verif/generator/tosa_test_gen.py b/verif/generator/tosa_test_gen.py
index 5d3984c..65bdeb7 100644
--- a/verif/generator/tosa_test_gen.py
+++ b/verif/generator/tosa_test_gen.py
@@ -28,6 +28,8 @@
     # This currently matches the 8K level defined in the specification.
     TOSA_TENSOR_MAX_RANK = 6
     TOSA_8K_LEVEL_MAX_SCALE = 64
+    TOSA_8K_LEVEL_MAX_KERNEL = 8192
+    TOSA_8K_LEVEL_MAX_STRIDE = 8192
 
     def __init__(self, args):
         self.args = args
@@ -2348,8 +2350,8 @@
                 invalid_test_validators = op["invalid_test_validators"]
                 clean_testList = []
                 for test in testList:
+                    remove_test = False
                     for validator_fcn in invalid_test_validators:
-                        remove_test = False
                         if validator_fcn(
                             opName=test[0],
                             input_dtype=test[2],
@@ -2371,6 +2373,9 @@
         except KeyError:
             raise Exception("Cannot find op with name {}".format(opName))
 
+        if self.args.verbose:
+            print(f"Creating {testStr}")
+
         # Create a serializer
         self.createSerializer(opName, testStr)
 
@@ -2461,7 +2466,13 @@
             return
 
         # Dynamically create op lists for convolutions with a list of kernel sizes
-        KERNELS_2D = [[1, 1], [2, 2], [3, 3], [5, 5], [3, 1], [1, 3]]
+        if not self.args.level8k:
+            KERNELS_2D = [[1, 1], [2, 2], [3, 3], [5, 5], [3, 1], [1, 3]]
+            KERNELS_3D = [[1, 1, 1], [2, 1, 1], [1, 2, 1], [1, 1, 2]]
+        else:
+            bigK = self.TOSA_8K_LEVEL_MAX_KERNEL
+            KERNELS_2D = [[1, bigK], [bigK, 2]]
+            KERNELS_3D = [[1, bigK, 1], [2, 2, bigK]]
 
         for k in KERNELS_2D:
             testName = "conv2d_{}x{}".format(k[0], k[1])
@@ -2483,7 +2494,6 @@
             self.TOSA_OP_LIST[testName]["filter"] = k
             self.TOSA_OP_LIST[testName]["template"] = False
 
-        KERNELS_3D = [[1, 1, 1], [2, 1, 1], [1, 2, 1], [1, 1, 2]]
         for k in KERNELS_3D:
             testName = "conv3d_{}x{}x{}".format(k[0], k[1], k[2])
             self.TOSA_OP_LIST[testName] = self.TOSA_OP_LIST["conv3d_TEMPLATE"].copy()