diff --git a/.gitignore b/.gitignore
index 43bd95c2b..a65fb8a12 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,7 @@ deploy_key
 temp_*.*
 .python-version
 .nox
+.venv
 
 ### Visual Studio Code ###
 !.vscode/settings.json
@@ -37,4 +38,11 @@ temp_*.*
 .LSOverride
 
 .vscode
-.idea
\ No newline at end of file
+.idea
+
+### JSON Schemas ###
+!kernel_tuner/schema/**/*.json
+
+### Tests ###
+!test/test_cache_files/**/*.json
+!test/test_convert_files/**/*.json
\ No newline at end of file
diff --git a/kernel_tuner/cache/__init__.py b/kernel_tuner/cache/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/kernel_tuner/cache/cache.py b/kernel_tuner/cache/cache.py
new file mode 100644
index 000000000..9c7e45a14
--- /dev/null
+++ b/kernel_tuner/cache/cache.py
@@ -0,0 +1,483 @@
+"""Provides utilities for reading and writing cache files.
+
+In order to modify and read cache files, the Cache class should be used, see its docstring.
+"""
+
+from __future__ import annotations
+
+import json
+from collections import OrderedDict
+from datetime import datetime
+from functools import cached_property
+from functools import lru_cache as cache
+from os import PathLike
+from pathlib import Path
+from typing import Any, Optional, Union, cast
+
+import jsonschema
+import numpy as np
+from kernel_tuner import util
+from semver import Version
+
+from .convert import convert_cache
+from .file import append_cache_line
+from .paths import get_schema_path
+from .versions import LATEST_VERSION, VERSIONS
+
+INFINITY = float("inf")
+
+
+def __get_schema_for_version(version: str):
+    schema_path = get_schema_path(version)
+    with open(schema_path, "r") as file:
+        return json.load(file)
+
+
+LATEST_SCHEMA = __get_schema_for_version(LATEST_VERSION)
+SCHEMA_REQUIRED_KEYS = LATEST_SCHEMA["required"]
+LINE_SCHEMA = LATEST_SCHEMA["properties"]["cache"]["additionalProperties"]
+RESERVED_PARAM_KEYS = set(LATEST_SCHEMA["properties"]["cache"]["additionalProperties"]["properties"].keys())
+
+
+class InvalidCacheError(Exception):
+    """Cache file reading or writing failed."""
+
+    def __init__(self, filename: PathLike, message: str, error: Optional[Exception] = None):
+        """Constructor for the InvalidCacheError class."""
+        super().__init__(str(filename), message, error)
+        self.filename = str(filename)
+        self.message = message
+        self.error = error
+
+
+class Cache(OrderedDict):
+    """Writes and reads cache files.
+
+    Cache files can be opened using ``Cache.open()`` and created using ``Cache.create()``. In both cases, a ``Cache``
+    instance is returned. This object simultaneously keeps track of the file, as well as its json contents in an
+    efficient manner. To read cache files of any old version, use `Cache.read()`, which returns a ``Cache`` instance
+    which which won't be able to be mutated. Note that the cache file should not be changed during the Cache instance's
+    lifetime, as the instance's state would in that case not correspond to the file's JSON content. To automatically
+    detect changes in the Cache instance, one could use os.path.getmtime() in order to detect whenever the cache file
+    changes.
+
+    The Cache class furthermore contains an easily usable interface for reading cache file properties, e.g.
+    `Cache.kernel_name` or `Cache.version`, and an easily usable interface for matching cache lines from their
+    parameters `Cache.lines.get()`, and an easily usable interface for appending cache lines `Cache.lines.append()`
+    to cache files.
+
+    Properties:
+        filepath: filepath to the cache.
+        version: schema version of the cache.
+        lines: cache lines of the json file.
+
+        device_name
+        kernel_name
+        problem_size
+        tune_params_keys
+        tune_params
+        objective
+
+    See Also:
+        Docstring from `Cache.Lines` explaining how to read and append cache lines
+        Docstring from `Cache.Line` explaining how to read properties from cache lines
+    """
+
+    @classmethod
+    def create(
+        cls,
+        filename: PathLike,
+        *,
+        device_name: str,
+        kernel_name: str,
+        problem_size: Any,
+        tune_params_keys: list[str],
+        tune_params: dict[str, list],
+        objective: str,
+    ) -> "Cache":
+        """Creates a new cache file.
+
+        For parameters of type Sequence, a list or tuple should be given as argument.
+
+        Returns a Cache instance of which the lines are modifiable.
+        """
+        if not isinstance(tune_params, dict) or not all(
+            isinstance(key, str) and isinstance(value, list) for key, value in tune_params.items()
+        ):
+            raise ValueError(
+                "Argument tune_params should be a dict with:\n"
+                "- keys being parameter keys (and all parameter keys should be used)\n"
+                "- values being the parameter's list of possible values"
+            )
+        if set(tune_params_keys) != set(tune_params.keys()):
+            raise ValueError("Expected tune_params to have exactly the same keys as in the list tune_params_keys")
+        if len(RESERVED_PARAM_KEYS & set(tune_params_keys)) > 0:
+            raise ValueError("Found a reserved key in tune_params_keys")
+
+        # main dictionary for new cache, note it is very important that 'cache' is the last key in the dict
+        schema_version = str(LATEST_VERSION)
+        inputs = {key: value for key, value in locals().items() if key in SCHEMA_REQUIRED_KEYS}
+        cache = Cache(filename=filename, read_only=False, **inputs)
+
+        write_cache_file(cache, filename)
+        return cache
+
+    @classmethod
+    def read(cls, filename: PathLike, read_only=False):
+        """Loads an existing cache. Returns a Cache instance.
+
+        If the cache file does not have the latest version, then it will be read after virtually converting it to the
+        latest version. The file in this case is kept the same.
+        """
+        cache_json = read_cache_file(filename)
+
+        # convert cache to latest schema if needed
+        if "schema_version" not in cache_json or cache_json["schema_version"] != LATEST_VERSION:
+            cache_json = convert_cache(cache_json)
+            # if not read-only mode, update the file
+            if not read_only:
+                write_cache_file(cast(dict, cache_json), filename)
+
+        cache = Cache(filename=filename, read_only=read_only, **cache_json)
+        return cache
+
+    def __init__(self, filename=None, read_only=False, **kwargs):
+        """Creates an instance of the Cache"""
+        self._filename = Path(filename)
+        self._read_only = read_only
+        super().__init__(**kwargs)
+        self.update(kwargs)
+
+        # ensure 'cache' key is present and is last in the dictionary
+        if "cache" not in self:
+            self["cache"] = {}
+        self.move_to_end("cache")
+
+        jsonschema.validate(instance=self, schema=LATEST_SCHEMA)
+
+        if read_only:
+            self.lines = Cache.ReadableLines(self, filename)
+        else:
+            self.lines = Cache.Lines(self, filename)
+
+    @cached_property
+    def filepath(self) -> Path:
+        """Returns the path to the cache file."""
+        return self._filename
+
+    @cached_property
+    def version(self) -> Version:
+        """Version of the cache file."""
+        return Version.parse(self["schema_version"])
+
+    def __getattr__(self, name):
+        if not name.startswith("_"):
+            return self[name]
+        return super(Cache, self).__getattr__(name)
+
+    class Lines(dict):
+        """Cache lines in a cache file.
+
+        Behaves exactly like an only readable dict, except with an `append` method for appending lines.
+
+        Usage Example:
+            cache: Cache = ...
+
+            print("Line with id 0,0,0 is ", cache.lines["0,0,0"])
+            print(f"There are {len(cache.lines)} lines")
+
+            cache.lines.append(..., tune_param_a=1, tune_param_b=2, tune_param_c=3)
+
+            print(f"There are {len(cache.lines)} lines")
+            for line_id, line in cache.lines.items():
+                print(f"Line {line_id} has value {line}.")
+
+            # If there are more tunable parameter keys than just "a",
+            # then cache.lines.get(a=...) returns a list.
+            for line in cache.lines.get(a=1):
+                print(f"Line {line} is one of the lines with `a=1`")
+
+        See Also:
+            collections.abc.Mapping: https://docs.python.org/3/library/collections.abc.html
+        """
+
+        def __init__(self, cache: Cache, filename: PathLike):
+            """Inits a new CacheLines instance."""
+            self._cache = cache
+            self._filename = filename
+            super().__init__()
+
+            for key, value in cache["cache"].items():
+                if not isinstance(value, Cache.Line):
+                    self[key] = Cache.Line(value)
+                else:
+                    self[key] = value
+
+        def append(self, **kwargs) -> None:
+            """Appends a cache line to the cache lines."""
+            if isinstance(kwargs[self._cache.objective], util.ErrorConfig):
+                kwargs[self._cache.objective] = str(kwargs[self._cache.objective])
+            line = Cache.Line(**kwargs)
+
+            tune_params = {key: value for key, value in kwargs.items() if key in self._cache.tune_params_keys}
+            line_id = self.__get_line_id_from_tune_params_dict(tune_params)
+            if line_id in self:
+                raise KeyError("Line with given tunable parameters already exists")
+
+            self[line_id] = line
+            line_str = _encode_cache_line(line_id, line)
+            append_cache_line(line_str, self._filename)
+
+        def get_from_params(self, default=None, **params) -> Union[Cache.Line, list[Cache.Line]]:
+            """Returns a cache line corresponding with ``line_id``.
+
+            If the line_id is given and not None, the line corresponding to ``line_id`` is returned. Otherwise the
+            keyword parameters are checked. If ``params`` contains all of the keys present in ``tune_params_keys``,
+            then these parameters are used to filter the element we want.
+
+            If all parameters from ``tune_params_keys`` are specified, a single line is returned, and ``default`` if it
+            does not exist. Otherwise a list containing all lines that match the given parameters are returned, and in
+            this case, default is disregarded.
+
+            It should be noted that partially matching the lines in the above manner is slow, as this implementation
+            generates the fill line ids for all of its matches. A future implementation might want to improve upon this
+            process with a custom datastructure.
+
+            If ``line_id`` is none and no parameters are defined, a list of all the lines is returned.
+            """
+            if not default:
+                default = []
+
+            if len(params) == 0:
+                return list(Cache.Line(line) for line in self.values())
+            if not all(key in self._cache.tune_params_keys for key in params):
+                raise ValueError("The keys in the parameters should be in `tune_params_keys`")
+
+            line_ids = self.__get_matching_line_ids(params)
+            results = [self[k] for k in line_ids]
+            if not results:
+                return default
+            if len(results) == 1:
+                results = results[0]
+            return results
+
+        def __get_line_id(self, param_list: list[Any]) -> str:
+            return json.dumps(param_list, separators=(",", ":"))[1:-1]
+
+        def __get_matching_line_ids(self, params: dict[str, Any]):
+            param_lists: list[list[Any]] = [[]]
+            for key in self._cache.tune_params_keys:
+                # If a tunable key is found, only match the value of the parameter
+                if key in params:
+                    value = params[key]
+                    for par_list in param_lists:
+                        par_list.append(value)
+                # If the tunable key is not present, generate all possible matchin keys
+                else:
+                    prev_lists = param_lists
+                    param_lists = []
+                    for value in self._cache.tune_params[key]:
+                        param_lists.extend(it + [value] for it in prev_lists)
+            return [line_id for line_id in map(self.__get_line_id, param_lists) if line_id in self]
+
+        def __get_line_id_from_tune_params_dict(self, tune_params: dict) -> str:
+            param_list = []
+            for key in self._cache.tune_params_keys:
+                if key in tune_params:
+                    value = tune_params[key]
+                    if value not in self._cache.tune_params[key]:
+                        raise ValueError(f"Invalid value {value} for tunable parameter {key}")
+                    param_list.append(value)
+                else:
+                    raise ValueError(f"Expected tune param key {key} to be present in parameters")
+            return self.__get_line_id(param_list)
+
+    class ReadableLines(Lines):
+        """Cache lines in a read_only cache file."""
+
+        def append(self, *args, **kwargs):
+            """Method to append lines to cache file, should not happen with read-only cache"""
+            raise ValueError("Attempting to write to read-only cache")
+
+    class Line(dict):
+        """Cache line in a cache file"""
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            # check if line has all the required fields and of correct types
+            jsonschema.validate(instance=self, schema=LINE_SCHEMA, format_checker=_get_format_checker())
+
+        def __getattr__(self, name):
+            if not name.startswith("_"):
+                return self[name]
+            return super(dict, self).__getattr__(name)
+
+
+def _encode_cache_line(line_id, line):
+    return json.dumps({line_id: line}, cls=CacheEncoder, indent=None).strip()[1:-1]
+
+
+@cache
+def _get_format_checker():
+    """Returns a JSON format checker instance."""
+    format_checker = jsonschema.FormatChecker()
+
+    @format_checker.checks("date-time")
+    def _check_iso_datetime(instance):
+        try:
+            datetime.fromisoformat(instance)
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    return format_checker
+
+
+class CacheEncoder(json.JSONEncoder):
+    """JSON encoder for Kernel Tuner cache lines.
+
+    Extend the default JSONEncoder with support for the following objects and types:
+
+    +-------------------+----------------------------------+
+    | Python            | JSON                             |
+    +===================+==================================+
+    | util.ErrorConfig  | str                              |
+    | np.integer        | int                              |
+    | np.floating       | float                            |
+    | np.ndarray        | list                             |
+    | dict              | object, with 'cache' as last key |
+    +-------------------+----------------------------------+
+
+    """
+
+    def __init__(self, *, indent=None, separators=None, **kwargs):
+        """Constructor for CacheJSONEncoder, with sensible defaults."""
+        if indent is None:
+            separators = (", ", ": ")
+
+        super().__init__(indent=indent, separators=separators, **kwargs)
+
+    def default(self, o):
+        """Converts non-jsonifiable objects to jsonifiable objects."""
+
+        if isinstance(o, util.ErrorConfig):
+            return str(o)
+        elif isinstance(o, np.integer):
+            return int(o)
+        elif isinstance(o, np.floating):
+            return float(o)
+        elif isinstance(o, np.ndarray):
+            return o.tolist()
+        return super().default(o)
+
+    def iterencode(self, obj, **kwargs):
+        """encode an iterator, ensuring 'cache' is the last entry for encoded dicts"""
+
+        # ensure key 'cache' is last in any encoded dictionary
+        if isinstance(obj, dict):
+            obj = OrderedDict(obj)
+            if "cache" in obj:
+                obj.move_to_end("cache")
+
+        yield from super().iterencode(obj, **kwargs)
+
+
+def read_cache_file(filename: PathLike):
+    """Reads a cache file and returns its content as a dictionary.
+
+    Parameters:
+        filename (PathLike): The path to the cache file.
+
+    Returns:
+        dict: The content of the cache file.
+    """
+    with open(filename, "r") as file:
+        try:
+            data = json.load(file)
+        except json.JSONDecodeError as e:
+            raise InvalidCacheError(filename, "Cache file is not parsable", e) from e
+    return data
+
+
+def write_cache_file(cache_json: dict, filename: PathLike):
+    """Writes a cache file with the given content.
+
+    Parameters:
+        cache_file (dict): The content to be written to the cache file.
+        filename (PathLike): The path to write the cache file.
+    """
+
+    # extract entries from cache
+    cache_entries = cache_json["cache"]
+    cache_json["cache"] = {}
+
+    # first write cache without entries
+    with open(filename, "w") as file:
+        json.dump(cache_json, file, cls=CacheEncoder, indent="  ")
+
+    # restore internal state
+    cache_json["cache"] = cache_entries
+
+    # add entries line by line
+    for key, line in cache_entries.items():
+        line_str = _encode_cache_line(key, line)
+        append_cache_line(line_str, filename)
+
+
+def convert_cache_file(filestr: PathLike, conversion_functions=None, versions=None, target_version=None):
+    """Convert a cache file to the latest/later version.
+
+    Parameters:
+        ``filestr`` is the name of the cachefile.
+
+        ``conversion_functions`` is a ``dict[str, Callable[[dict], dict]]``
+        mapping a version to a corresponding conversion function.
+
+        ``versions`` is a sorted ``list`` of ``str``s containing the versions.
+
+        ``target`` is the version that the cache should be converted to. By
+        default it is the latest version in ``versions``.
+
+    Raises:
+        ``ValueError`` if:
+
+            given cachefile has no "schema_version" field and can not be converted
+            to version 1.0.0,
+
+            the cachefile's version is higher than the newest version,
+
+            the cachefile's version is not a real version.
+    """
+    # Load cache from file
+    cache = read_cache_file(filestr)
+
+    # Convert cache
+    cache = convert_cache(cache, conversion_functions, versions, target_version)
+
+    # Update cache file
+    write_cache_file(cache, filestr)
+
+
+def validate(filename: PathLike):
+    """Validates a cache file and raises an error if invalid."""
+    cache_json = read_cache_file(filename)
+    validate_json(cache_json)
+
+
+def validate_json(cache_json: Any):
+    """Validates cache json."""
+    if "schema_version" not in cache_json:
+        raise jsonschema.ValidationError("Key 'schema_version' is not present in cache data")
+    schema_version = cache_json["schema_version"]
+    __validate_json_schema_version(schema_version)
+    schema = __get_schema_for_version(schema_version)
+    jsonschema.validate(instance=cache_json, schema=schema, format_checker=_get_format_checker())
+
+
+def __validate_json_schema_version(version: str):
+    try:
+        if Version.parse(version) in VERSIONS:
+            return
+    except (ValueError, TypeError):
+        pass
+    raise jsonschema.ValidationError(f"Invalid version {repr(version)} found.")
diff --git a/kernel_tuner/cache/cli_tools.py b/kernel_tuner/cache/cli_tools.py
new file mode 100644
index 000000000..003b9797c
--- /dev/null
+++ b/kernel_tuner/cache/cli_tools.py
@@ -0,0 +1,159 @@
+"""This module contains several functions used to perform several operations on cachefiles."""
+
+import json
+from os import PathLike
+from shutil import copyfile
+from typing import Any, List
+
+from .cache import (
+    Cache,
+    CacheEncoder,
+    convert_cache_file,
+    read_cache_file,
+    validate,
+    write_cache_file,
+)
+from .convert import convert_cache_to_t4
+
+
+def assert_cache_files_have_compatible_headers(file_list: List[PathLike]):
+    """Checks equivalence of set parameters for files in `file_list`.
+
+    Assumes that all files have been validated.
+    We use the first file (file_list[0]) as our base file, and compare everything with that.
+    """
+    base_file = Cache.read(file_list[0], read_only=True)
+
+    for file in file_list[1:]:
+        temp_file = Cache.read(file, read_only=True)
+
+        # Now the equivalence logic
+
+        if base_file.version != temp_file.version:
+            raise ValueError(f"Merge error; files '{file_list[0]}' and '{file}' do not have the same schema version.")
+
+        elif base_file.device_name != temp_file.device_name:
+            raise ValueError(f"Merge error; key 'device_name' not equivalent for '{file_list[0]}' and '{file}'.")
+
+        elif base_file.kernel_name != temp_file.kernel_name:
+            raise ValueError(f"Merge error; key 'kernel_name' not equivalent for '{file_list[0]}' and '{file}'.")
+
+        elif base_file.problem_size != temp_file.problem_size:
+            raise ValueError(f"Merge error; key 'problem_size' not equivalent for '{file_list[0]}' and '{file}'.")
+
+        elif base_file.objective != temp_file.objective:
+            raise ValueError(f"Merge error; key 'objective' not equivalent for '{file_list[0]}' and '{file}'.")
+
+        elif base_file.tune_params_keys != temp_file.tune_params_keys:
+            raise ValueError(f"Merge error; key 'tune_params_keys' not equivalent for '{file_list[0]}' and '{file}'.")
+
+
+def merge_files(cache_files: List[PathLike], output_path: PathLike):
+    """Merges the actual files and writes to the file `ofile`.
+
+    Assumes that all files have been validated.
+    Does not guarantee to preserve order within cache files.
+    """
+    # From cache.py (json.load).
+
+    cache = Cache.read(cache_files[0], read_only=True)
+    output = Cache.create(
+        output_path,
+        device_name=cache.device_name,
+        kernel_name=cache.kernel_name,
+        problem_size=cache.problem_size,
+        tune_params_keys=cache.tune_params_keys,
+        tune_params=cache.tune_params,
+        objective=cache.objective,
+    )
+
+    # Now for each file add the cache content.
+    for file in cache_files:
+        input_file = Cache.read(file, read_only=True)
+        for line in input_file.lines.values():
+            output.lines.append(**line)
+
+
+def get_line(infile: PathLike, key: str):
+    """Checks if entry (string) `key` is inside file `in_file`, by using the `cache.py` library."""
+    cache_infile = Cache.read(infile, read_only=True)
+
+    cache_line = cache_infile.lines[key]
+
+    print(f"[*] Cacheline entry '{key}' content [*]\n\n", "************************")
+    print(dict(cache_line))
+    print("************************")
+
+
+def delete_line(infile: PathLike, key: str, outfile):
+    """Tries to remove entry `key` from file `infile`, then write to `outfile` by using the `cache.py` functions.
+
+    First we check if the entry actually exists in the cachefile using the library. If not, there
+    is nothing to do.
+    If it exists, we delete by inverse-appending.
+    """
+    if outfile is None:
+        outfile = infile
+
+    cache_infile = Cache.read(infile, read_only=True)
+    if cache_infile.lines.get(key) is None:
+        raise KeyError(f"Entry '{key}' is not contained in cachefile '{infile}'.")
+
+    output = Cache.create(
+        outfile,
+        device_name=cache_infile.device_name,
+        kernel_name=cache_infile.kernel_name,
+        problem_size=cache_infile.problem_size,
+        tune_params_keys=cache_infile.tune_params_keys,
+        tune_params=cache_infile.tune_params,
+        objective=cache_infile.objective,
+    )
+
+    for k, line in cache_infile.lines.items():
+        if k != key:
+            output.lines.append(**line)
+
+
+def convert(read_file: PathLike, write_file=None, target=None, allow_version_absence=False):
+    """The main function for handling the version conversion of a cachefile."""
+    # Check if the `read_file` is actually a valid cachefile, in case it is versioned.
+    if not allow_version_absence:
+        validate(read_file)
+
+    # If no output file is specified, let the conversion overwrite the input file
+    if write_file is None:
+        write_file = read_file
+    else:
+        copyfile(read_file, write_file)
+
+    convert_cache_file(filestr=write_file, target_version=target)
+
+
+def convert_t4(read_file: PathLike, write_file: PathLike):
+    """The main function for handling the T4 conversion of a cachefile."""
+    cache = read_cache_file(read_file)
+
+    t4_cache: Any = convert_cache_to_t4(cache)
+
+    with open(write_file, "w") as file:
+        json.dump(t4_cache, file, cls=CacheEncoder, indent="  ")
+
+
+def merge(file_list: List[PathLike], outfile: PathLike):
+    """The main function for handling the merging of two or more cachefiles.
+
+    First, we must validate the existence and validity of cachefiles, then we merge.
+    """
+    if len(file_list) < 2:
+        raise ValueError("Not enough (< 2) files provided to merge.")
+
+    # Perform validation, conversion, equivalence check and after merge.
+
+    for i in file_list:
+        validate(i)
+
+    # Convert all files in `file_list` that are not matching the newest `schema_version` to the newest schema version.
+    # Write the converted result to the same file.
+    assert_cache_files_have_compatible_headers(file_list)
+
+    merge_files(file_list, outfile)
diff --git a/kernel_tuner/cache/convert.py b/kernel_tuner/cache/convert.py
new file mode 100644
index 000000000..1749fdd46
--- /dev/null
+++ b/kernel_tuner/cache/convert.py
@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Callable
+
+import semver
+
+from kernel_tuner.cache.json import (
+    CacheFileJSON,
+    T4FileJSON,
+    T4ResultLineJSON,
+    T4ResultMeasurementJSON,
+    T4ResultTimesJSON,
+)
+from kernel_tuner.cache.paths import CACHE_SCHEMAS_DIR
+from kernel_tuner.cache.versions import VERSIONS
+
+CONVERSION_FUNCTIONS: dict[str, Callable[[dict], dict]]
+
+DEFAULT_VALUES = {
+    "object": {},
+    "array": [],
+    "string": "default string",
+    "integer": 0,
+    "number": 0,
+    "true": True,
+    "false": False,
+    "null": None,
+}
+
+
+def convert_cache(cache: dict, conversion_functions=None, versions=None, target_version=None) -> dict:
+    """Convert a cache dict to the latest/later version.
+
+    Parameters:
+        ``cache`` is the cache dictionary
+
+        ``conversion_functions`` is a ``dict[str, Callable[[dict], dict]]``
+        mapping a version to a corresponding conversion function.
+
+        ``versions`` is a sorted ``list`` of ``str``s containing the versions.
+
+        ``target`` is the version that the cache should be converted to. By
+        default it is the latest version in ``versions``.
+
+    Raises:
+        ``ValueError`` if:
+
+            given cachefile has no "schema_version" field and can not be converted
+            to version 1.0.0,
+
+            the cachefile's version is higher than the newest version,
+
+            the cachefile's version is not a real version.
+    """
+    if conversion_functions is None:
+        conversion_functions = CONVERSION_FUNCTIONS
+
+    if versions is None:
+        versions = list(map(str, VERSIONS))
+
+    if target_version is None:
+        target_version = versions[-1]
+
+    if "schema_version" not in cache:
+        cache = unversioned_convert(cache, CACHE_SCHEMAS_DIR)
+
+    version = cache["schema_version"]
+
+    if semver.VersionInfo.parse(version).compare(target_version) > 0:
+        raise ValueError(
+            f"Target version ({target_version}) should not be smaller than the cache's version ({version})"
+        )
+
+    if version not in versions:
+        raise ValueError(f"Version ({version}) should be a real existing version")
+
+    if target_version not in versions:
+        raise ValueError(f"Target version ({target_version}) should be a real existing version")
+
+    # Main convert loop
+    while version != target_version:
+        if version in conversion_functions:
+            cache = conversion_functions[version](cache)
+        else:
+            cache = default_convert(cache, version, versions, CACHE_SCHEMAS_DIR)
+
+        version = cache["schema_version"]
+
+    return cache
+
+
+def default_convert(cache: dict, oldver: str, versions: list, schema_path: Path) -> dict:
+    """Attempts a default conversion of ``cache`` to the next highest version.
+
+    Parameters:
+        ``cache`` is a ``dict`` representing the cachefile.
+
+        ``oldver`` is the version of the cachefile.
+
+        ``versions`` is a sorted ``list`` of ``str``s containing the versions.
+
+        ``schema_path`` is a ``pathlib`` ``Path``  to the directory containing
+        the schema versions.
+
+    Returns:
+        a ``dict`` representing the converted cache file.
+    """
+    # Get the next version
+    parts = ["patch", "minor", "major"]
+    for part in parts:
+        newver = str(semver.VersionInfo.parse(oldver).next_version(part))
+        if newver in versions:
+            break
+
+    old_schema_path = schema_path / oldver / "schema.json"
+    new_schema_path = schema_path / newver / "schema.json"
+
+    with open(old_schema_path) as o, open(new_schema_path) as n:
+        old_schema = json.load(o)
+        new_schema = json.load(n)
+
+    new_cache = {}
+    for key in new_schema["properties"]:
+        # It may be the case that the cache does't have a key because it is not
+        # required, so check if the key is in the cache
+        if key in old_schema["properties"] and key in cache:
+            new_cache[key] = cache[key]
+        else:
+            new_cache[key] = DEFAULT_VALUES[(new_schema["properties"][key]["type"])]
+
+    new_cache["schema_version"] = newver
+
+    return new_cache
+
+
+def unversioned_convert(cache: dict, schema_path: Path) -> dict:
+    """Attempts a conversion of an unversioned cache file to version 1.0.0.
+
+    Parameters:
+        ``cache`` is a ``dict`` representing the cachefile.
+
+    Returns:
+        a ``dict`` representing the converted cache file.
+
+    Raises:
+        ``ValueError`` if given cache file is too old and no suitable
+        conversion exists.
+    """
+    cache["schema_version"] = "1.0.0"
+
+    if "objective" not in cache:
+        cache["objective"] = "time"
+
+    for key, entry in cache["cache"].items():
+        if "timestamp" not in entry:
+            cache["cache"][key]["timestamp"] = "2024-06-18 11:36:56.137831+00:00"
+        for missing_key in ["compile_time", "benchmark_time", "framework_time", "strategy_time"]:
+            if missing_key not in entry:
+                cache["cache"][key][missing_key] = 0
+
+    path = schema_path / "1.0.0/schema.json"
+
+    with open(path) as s:
+        versioned_schema = json.load(s)
+
+    missing_keys = [key for key in versioned_schema["properties"] if key not in cache]
+    if missing_keys:
+        raise ValueError(
+            f"Cache file too old, missing key{'s' if len(missing_keys) > 1 else ''} "
+            + f"{', '.join(missing_keys)}, no suitable conversion to version 1.0.0 exists."
+        )
+
+    return cache
+
+
+def convert_cache_to_t4(cache: CacheFileJSON) -> T4FileJSON:
+    """Converts a cache file to the T4 auto-tuning format.
+
+    ``cache`` is a ``CacheFileJSON`` representing the cache file to convert.
+
+    Returns a ``T4FileJSON`` representing the converted cache file.
+    """
+    t4 = T4FileJSON(metadata={"timeunit": "miliseconds"}, results=[], schema_version="1.0.0")
+
+    for cache_line in cache["cache"].values():
+        times = T4ResultTimesJSON(
+            compilation=cache_line["compile_time"],
+            framework=cache_line["framework_time"],
+            search_algorithm=cache_line["strategy_time"],
+            validation=cache_line["verification_time"],
+        )
+        # In case of invalid configurations 'times' might be omitted in cache_line
+        if "times" in cache_line:
+            times["runtimes"] = cache_line["times"]
+        elif "benchmark_time" in cache_line:
+            times["runtimes"] = [cache_line["benchmark_time"]]
+
+        measurement = T4ResultMeasurementJSON(name=cache["objective"], value=cache_line[cache["objective"]], unit="")
+
+        # Convert Kernel Tuner's ErrorConfig instances to 'invalidity' strings supported in T4
+        invalidity = "correct"
+        objective_value = cache_line[cache["objective"]]
+        if isinstance(objective_value, str):
+            # The kernel configuration is invalid
+            if objective_value == "CompilationFailedConfig":
+                invalidity = "compile"
+            elif objective_value == "RuntimeFailedConfig":
+                invalidity = "runtime"
+            elif objective_value == "InvalidConfig":
+                invalidity = "constraints"
+
+        result = T4ResultLineJSON(
+            timestamp=cache_line["timestamp"],
+            configuration={tune_param_key: cache_line[tune_param_key] for tune_param_key in cache["tune_params_keys"]},
+            times=times,
+            # We assume that the supplied cache file is correct
+            invalidity=invalidity,
+            correctness=1 if invalidity == "correct" else 0,
+            measurements=[measurement],
+            objectives=[cache["objective"]],
+        )
+        t4["results"].append(result)
+
+    return t4
+
+
+########################################################################
+# Add conversion functions here which:                                 #
+#                                                                      #
+# have "_c<old version>_to_<new version>" as name,                     #
+# have a single argument 'cache',                                      #
+# return 'cache'.                                                      #
+#                                                                      #
+# The conversion functions are expected to change the "schema_version" #
+# field to <new version> themselves.                                   #
+#                                                                      #
+# For example:                                                         #
+# def _c_1_0_0_to_1_1_0(cache):                                        #
+#     ...                                                              #
+#     cache["schema_version"] = "1.1.0"                                #
+#     return cache                                                     #
+#                                                                      #
+# the list of conversion functions then has to be updated, like this:  #
+# CONVERSION_FUNCTIONS = {                                             #
+#    ...                                                               #
+#    "1.0.0": _c_1_0_0_to_1_1_0,                                       #
+#    ...                                                               #
+# }                                                                    #
+########################################################################
+
+CONVERSION_FUNCTIONS = {}
diff --git a/kernel_tuner/cache/file.py b/kernel_tuner/cache/file.py
new file mode 100644
index 000000000..22482761a
--- /dev/null
+++ b/kernel_tuner/cache/file.py
@@ -0,0 +1,98 @@
+"""Provides utilities for reading and writing cachefiles."""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+from os import PathLike
+from typing import Callable, Optional
+
+
+
+class CachedLinePosition:
+    """Position of a cache line in a cache file."""
+
+    is_initialized: bool = False
+    is_first_line: bool = False
+    file_position: int = 0
+
+
+def append_cache_line(
+    cache_line: str, filename: PathLike, position: Optional[CachedLinePosition] = None
+) -> CachedLinePosition:
+    """Appends a cache line to an open cache file.
+
+    If ``position`` is unset, it will assume the "cache" property comes last in the root object when determining the
+    position to insert the cache line at.
+
+    Returns the position of the next cache line.
+    """
+    p = position or CachedLinePosition()
+    if not p.is_initialized:
+        _unsafe_get_next_cache_line_position(filename, p)
+    return _append_cache_line_at(cache_line, filename, p)
+
+
+def _append_cache_line_at(
+    cache_line: str, filename: PathLike, position: CachedLinePosition
+) -> CachedLinePosition:
+    with open(filename, "r+") as file:
+        # Save cache closing braces properties coming after "cache" as text in suffix
+        file.seek(position.file_position)
+        after_text = file.read()
+
+        # Append the cache line at the right position in the file
+        file.seek(position.file_position)
+        text = ""
+        if not position.is_first_line:
+            text += ","
+        text += "\n"
+        text += cache_line
+        file.write(text)
+
+        # Update the position
+        next_pos = CachedLinePosition()
+        next_pos.is_initialized = True
+        next_pos.is_first_line = False
+        next_pos.file_position = file.tell()
+
+        # Close off the cache
+        file.write(after_text)
+        file.truncate()
+
+    return next_pos
+
+
+# This function only works when "cache" property is stored last
+def _unsafe_get_next_cache_line_position(filename: PathLike, state: CachedLinePosition):
+    with open(filename, "rb+") as file:
+        # Seek the last `}` (root closing brace)
+        file.seek(0, os.SEEK_END)
+        _seek_back_while(lambda ch: ch != b"}", file)
+
+        # Seek the second last `}` ("cache" property closing brace)
+        file.seek(-1, os.SEEK_CUR)
+        _seek_back_while(lambda ch: ch != b"}", file)
+
+        # Test if the cache object is empty
+        _seek_back_while(lambda ch: ch.isspace(), file)
+        state.is_first_line = file.peek(1).startswith(b"{")
+        file.seek(1, os.SEEK_CUR)
+
+        # Find the current position in the cache file
+        state.file_position = file.tell()
+
+    # Mark that the state has been initialized
+    state.is_initialized = True
+
+
+def _seek_back_while(predicate: Callable[[bytes], bool], buf: io.BufferedRandom):
+    while predicate(_read_back(buf)):
+        pass
+
+
+def _read_back(buf: io.BufferedRandom, size=1):
+    buf.seek(-size, os.SEEK_CUR)
+    ch = buf.peek(size)[:size]
+    return ch
diff --git a/kernel_tuner/cache/json.py b/kernel_tuner/cache/json.py
new file mode 100644
index 000000000..57db1cb98
--- /dev/null
+++ b/kernel_tuner/cache/json.py
@@ -0,0 +1,71 @@
+"""Provides types for cache in JSON format."""
+
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+_CacheLineOptionalJSON = TypedDict("_CacheLineOptionalJSON", {})
+
+
+class CacheLineOptionalJSON(TypedDict, _CacheLineOptionalJSON, total=False):
+    """TypedDict for optional data in a cache line."""
+
+    times: list[float]
+
+
+class CacheLineJSON(TypedDict, CacheLineOptionalJSON):
+    """TypedDict for data required in a cache line."""
+
+    time: Any
+    compile_time: float
+    verification_time: float
+    benchmark_time: float
+    strategy_time: float
+    framework_time: float
+    timestamp: str
+
+
+class CacheFileJSON(TypedDict):
+    """TypedDict for the contents of a cache file."""
+
+    schema_version: str
+    device_name: str
+    kernel_name: str
+    problem_size: str
+    tune_params_keys: list[str]
+    tune_params: dict[str, list]
+    objective: str
+    cache: dict[str, CacheLineJSON]
+
+class T4ResultMeasurementJSON(TypedDict):
+    """TypedDict for the measurements of a T4 result line."""
+
+    name: str
+    value: float
+    unit: str
+
+class T4ResultTimesJSON(TypedDict):
+    """TypedDict for the times of a T4 result line."""
+
+    compilation: float
+    framework: float
+    search_algorithm: float
+    validation: float
+    runtimes: list[float]
+
+class T4ResultLineJSON(TypedDict):
+    """TypedDict for the contents of a T4 result line."""
+
+    timestamp: str
+    configuration: dict[str, Any]
+    times: T4ResultTimesJSON
+    invalidity: str
+    correctness: int
+    measurements: list[T4ResultMeasurementJSON]
+    objectives: list[str]
+
+class T4FileJSON(TypedDict):
+    """TypedDict for the contents of a T4 file."""
+
+    results: list[T4ResultLineJSON]
+    schema_version: str
diff --git a/kernel_tuner/cache/paths.py b/kernel_tuner/cache/paths.py
new file mode 100644
index 000000000..ca8b02649
--- /dev/null
+++ b/kernel_tuner/cache/paths.py
@@ -0,0 +1,17 @@
+"""Module containing paths within Kernel Tuner."""
+
+from pathlib import Path
+from typing import Union
+
+from semver import Version
+
+import kernel_tuner
+
+PROJECT_DIR = Path(kernel_tuner.__file__).parent
+SCHEMA_DIR = PROJECT_DIR / "schema"
+CACHE_SCHEMAS_DIR = SCHEMA_DIR / "cache"
+
+
+def get_schema_path(version: Union[Version, str]):
+    """Returns the path to the schema of the cache of a specific version."""
+    return CACHE_SCHEMAS_DIR / str(version) / "schema.json"
diff --git a/kernel_tuner/cache/versions.py b/kernel_tuner/cache/versions.py
new file mode 100644
index 000000000..1bc28cef2
--- /dev/null
+++ b/kernel_tuner/cache/versions.py
@@ -0,0 +1,11 @@
+"""Versions of the cache files."""
+
+from __future__ import annotations
+
+from semver import Version
+
+from .paths import CACHE_SCHEMAS_DIR
+
+SORTED_VERSIONS: list[Version] = sorted(Version.parse(p.name) for p in CACHE_SCHEMAS_DIR.iterdir())
+VERSIONS: list[Version] = SORTED_VERSIONS
+LATEST_VERSION: Version = VERSIONS[-1]
diff --git a/kernel_tuner/energy/energy.py b/kernel_tuner/energy/energy.py
index ab0582c52..996ef8094 100644
--- a/kernel_tuner/energy/energy.py
+++ b/kernel_tuner/energy/energy.py
@@ -2,7 +2,8 @@
 import numpy as np
 from scipy import optimize
 
-from kernel_tuner import tune_kernel, util
+from kernel_tuner import tune_kernel
+from kernel_tuner.cache.cache import Cache
 from kernel_tuner.observers.nvml import NVMLObserver, get_nvml_gr_clocks
 
 try:
@@ -54,10 +55,10 @@ def get_frequency_power_relation_fp32(device, n_samples=10, nvidia_smi_fallback=
         nvml_gr_clocks = get_nvml_gr_clocks(device, n=n_samples, quiet=True)
 
     else:
-        cached_data = util.read_cache(cache, open_cache=False)
-        multiprocessor_count = cached_data["problem_size"][0]
-        max_block_dim_x = cached_data["tune_params"]["block_size_x"][0]
-        nvml_gr_clocks = cached_data["tune_params"]
+        c = Cache.read(cache)
+        multiprocessor_count = c.problem_size[0]
+        max_block_dim_x = c.tune_params["block_size_x"][0]
+        nvml_gr_clocks = c.tune_params
 
     # kernel arguments
     data_size = (multiprocessor_count, max_block_dim_x)
diff --git a/kernel_tuner/interface.py b/kernel_tuner/interface.py
index 97ae22848..2eae3a41f 100644
--- a/kernel_tuner/interface.py
+++ b/kernel_tuner/interface.py
@@ -692,9 +692,6 @@ def tune_kernel(
     elif not device_options.quiet:
         print("no results to report")
 
-    if cache:
-        util.close_cache(cache)
-
     # get the seperate timings for the benchmarking process
     overhead_time = 1000 * (perf_counter() - start_overhead_time)
     env = util.get_total_timings(results, env, overhead_time)
diff --git a/kernel_tuner/runners/sequential.py b/kernel_tuner/runners/sequential.py
index aeebd5116..167d5a193 100644
--- a/kernel_tuner/runners/sequential.py
+++ b/kernel_tuner/runners/sequential.py
@@ -3,9 +3,10 @@
 from datetime import datetime, timezone
 from time import perf_counter
 
+from kernel_tuner.cache.cache import Cache
 from kernel_tuner.core import DeviceInterface
 from kernel_tuner.runners.runner import Runner
-from kernel_tuner.util import ErrorConfig, print_config_output, process_metrics, store_cache
+from kernel_tuner.util import ErrorConfig, print_config_output, process_metrics
 
 
 class SequentialRunner(Runner):
@@ -100,9 +101,9 @@ def run(self, parameter_space, tuning_options):
                 params = process_metrics(params, tuning_options.metrics)
 
             # get the framework time by estimating based on other times
-            total_time = 1000 * ((perf_counter() - self.start_time) - warmup_time) 
+            total_time = 1000 * ((perf_counter() - self.start_time) - warmup_time)
             params['strategy_time'] = self.last_strategy_time
-            params['framework_time'] = max(total_time - (params['compile_time'] + params['verification_time'] + params['benchmark_time'] + params['strategy_time']), 0)
+            params['framework_time'] = max(total_time - (params['compile_time'] + params['verification_time'] + params['benchmark_time'] + params['strategy_time']), 0.0)
             params['timestamp'] = str(datetime.now(timezone.utc))
             self.start_time = perf_counter()
 
@@ -111,7 +112,8 @@ def run(self, parameter_space, tuning_options):
                 print_config_output(tuning_options.tune_params, params, self.quiet, tuning_options.metrics, self.units)
 
                 # add configuration to cache
-                store_cache(x_int, params, tuning_options)
+                if isinstance(tuning_options.cache, Cache.Lines) and tuning_options.cache.get(x_int) is None:
+                    tuning_options.cache.append(**params)
 
             # all visited configurations are added to results to provide a trace for optimization strategies
             results.append(params)
diff --git a/kernel_tuner/runners/simulation.py b/kernel_tuner/runners/simulation.py
index 22c7c667c..ff6e13298 100644
--- a/kernel_tuner/runners/simulation.py
+++ b/kernel_tuner/runners/simulation.py
@@ -88,7 +88,7 @@ def run(self, parameter_space, tuning_options):
             # check if element is in the cache
             x_int = ",".join([str(i) for i in element])
             if tuning_options.cache and x_int in tuning_options.cache:
-                result = tuning_options.cache[x_int].copy()
+                result = tuning_options.cache[x_int]
 
                 # Simulate behavior of sequential runner that when a configuration is
                 # served from the cache by the sequential runner, the compile_time,
diff --git a/kernel_tuner/schema/cache/1.0.0/schema.json b/kernel_tuner/schema/cache/1.0.0/schema.json
new file mode 100644
index 000000000..b00263281
--- /dev/null
+++ b/kernel_tuner/schema/cache/1.0.0/schema.json
@@ -0,0 +1,127 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "description": "Schema for analyzing Kernel Tuner cache files, capturing parameters and metrics to facilitate easy comparison of tuning configurations and performance results",
+    "type": "object",
+    "properties": {
+        "schema_version": {
+            "type": "string",
+            "description": "The version of this JSON-schema, adhering to the Semantic Versioning specification.",
+            "const": "1.0.0"
+        },
+        "device_name": {
+            "type": "string",
+            "description": "The name of the device the kernel tuner analysis is run on."
+        },
+        "kernel_name": {
+            "type": "string",
+            "description": "The name of the kernel."
+        },
+        "problem_size": {
+            "oneOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "integer"
+                  }
+                },
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "string"
+                }
+            ],
+            "description": "The size of the problem."
+        },
+        "tune_params_keys": {
+            "type": "array",
+            "description": "The keys (names) of all the parameters being tuned.",
+            "items": {
+                "type": "string"
+            }
+        },
+        "tune_params": {
+            "type": "object",
+            "description": "The nested JSON object containing for each parameter the array of tuning values.",
+            "additionalProperties": {
+                "type": "array"
+            }
+        },
+        "objective": {
+            "type": "string",
+            "description": "The objective with kernel."
+        },
+        "cache": {
+            "type": "object",
+            "description": "The actual data; the data of the instances cached.",
+            "additionalProperties": {
+                "type": "object",
+                "properties": {
+                    "time": {
+                        "anyOf": [
+                            {
+                                "type": "string",
+                                "enum": [
+                                    "InvalidConfig",
+                                    "CompilationFailedConfig",
+                                    "RuntimeFailedConfig"
+                                ]
+                            },
+                            {
+                                "type": "number"
+                            }
+                        ]
+                    },
+                    "times": {
+                        "type": "array",
+                        "items": {
+                            "type": "number"
+                        }
+                    },
+                    "compile_time": {
+                        "type": "number"
+                    },
+                    "verification_time": {
+                        "type": "number"
+                    },
+                    "benchmark_time": {
+                        "type": "number"
+                    },
+                    "GFLOP/s": {
+                        "type": "number"
+                    },
+                    "strategy_time": {
+                        "type": "number"
+                    },
+                    "framework_time": {
+                        "type": "number"
+                    },
+                    "timestamp": {
+                        "type": "string",
+                        "format": "date-time"
+                    }
+                },
+                "required": [
+                    "time",
+                    "compile_time",
+                    "verification_time",
+                    "benchmark_time",
+                    "strategy_time",
+                    "framework_time",
+                    "timestamp"
+                ],
+                "additionalProperties": true
+            }
+        }
+    },
+    "required": [
+        "schema_version",
+        "device_name",
+        "kernel_name",
+        "problem_size",
+        "tune_params_keys",
+        "tune_params",
+        "objective",
+        "cache"
+    ]
+}
\ No newline at end of file
diff --git a/kernel_tuner/scripts/ktcache.py b/kernel_tuner/scripts/ktcache.py
new file mode 100644
index 000000000..fa82e148c
--- /dev/null
+++ b/kernel_tuner/scripts/ktcache.py
@@ -0,0 +1,172 @@
+"""The CLI tool to manipulate kernel tuner cache files.
+
+Works with the cache file manipulation library (cache.py),
+conversion functionality (convert.py) and other helper functions (defined in cli_functionality.py).
+
+Basic usage:
+$ ktcache {convert, t4, delete-line, get-line, merge}
+
+We can:
+   - `convert`: using the functionality from convert.py one can convert to a specified version.
+      Within conversion (all required yet nonpositional arguments):
+         - `-i/--infile`: the input file to read from.
+         - `-T/--target`: The version to convert to.
+         - `--out/--output`: The converted output file.
+         - `--force-version-absence`: allow unversioned cachefiles to be converted.
+
+
+   - `t4`: using the functionality from convert.py one can convert to T4 format.
+      Within t4 conversion:
+         - `-i/--infile`: the input file to read from.
+         - `-o/--output`: the t4-converted output file.
+
+   - `delete-line`: using the cache library one can delete from a certain cachefile; only works with the latest
+      schema_version.
+      We have arguments:
+         - <infile>: the input file to delete the entry.
+         - `--key`: The key to try and delete.
+         - ``: the new output file.
+
+   - `get-line`: using the cache library one can get a certain cacheline entry from the input cachefile.
+      Prints in JSON.
+      We have arugments:
+         - <infile>: the input file to get the cacheline entry from.
+         - (Required) `--key`: The key to check if present in the cachefile.
+
+   - `merge`: merge several (>=2) cache files that are of the same jsonschema and have equivalent metadata, to the
+      latest schema_version.
+      Arguments are (all required):
+         - <files>: The list of (space separated) input files to read in order to merge the cachefiles.
+         - `-o, --output`: The output file to write the merged result to.
+
+
+"""
+
+# import required files from within kernel tuner
+import argparse
+import sys
+
+from kernel_tuner.cache.cli_tools import convert, convert_t4, delete_line, get_line, merge
+
+
+def cli_convert(ap_res: argparse.Namespace):
+    """The main function for handling conversion to a `schema_version` in the cli."""
+    convert(
+        ap_res.infile,
+        write_file=ap_res.output,
+        target=ap_res.target,
+        allow_version_absence=ap_res.allow_version_absence,
+    )
+
+
+def cli_delete_line(ap_res: argparse.Namespace):
+    """The main function for handling deletion of a cacheline using `delete-line` in the cli."""
+    delete_line(ap_res.infile[0], ap_res.key, outfile=ap_res.output)
+
+
+def cli_getline(ap_res: argparse.Namespace):
+    """The main function for getting a line using `get-line` in the cli."""
+    get_line(ap_res.infile[0], ap_res.key)
+
+
+def cli_merge(ap_res: argparse.Namespace):
+    """The main function for merging several cachefiles using `merge` in the cli."""
+    merge(ap_res.files, ap_res.output)
+
+
+def cli_t4(ap_res: argparse.Namespace):
+    """The main function for handling conversion to t4 format in the cli."""
+    convert_t4(ap_res.infile, write_file=ap_res.output)
+
+
+def parse_args(args):
+    """The main parsing function.
+
+    Uses argparse to parse, then calls the appropiate function, one of:
+    cli_{convert, delete-line, get-line, merge}.
+    """
+    # Setup parsing
+
+    parser = argparse.ArgumentParser(
+        prog="ktcache",
+        description="A CLI tool to manipulate kernel tuner cache files.",
+        epilog="Example usages:\n\n"
+        "ktcache convert --in a.json -T 1.1.0 --out b.json\n"
+        "ktcache convert --in a.json -T 1.1.0 --out b.json --allow-version-absence\n"
+        "ktcache delete-line 1.json --key 1,2,3,4 --out 2.json\n"
+        "ktcache get-line file.json --key 1,2,3,4\n"
+        "ktcache t4 --in x.json --out y.json\n"
+        "ktcache merge 1.json 2.json 3.json --out 4.json\n\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    sp = parser.add_subparsers(
+        required=True, help="Possible subcommands: 'convert', 'delete-line', 'get-line' and 'inspect'."
+    )
+
+    convert = sp.add_parser("convert", help="Convert a cache file from one version to another.")
+    convert.add_argument("--in", "--infile", required=True, help="The input cache file to read from.", dest="infile")
+    convert.add_argument("--out", "--output", help="The (optional) output JSON file to write to.", dest="output")
+    convert.add_argument("-T", "--target", help="The destination target version. By default the newest version")
+    convert.add_argument(
+        "--allow-version-absence",
+        dest="allow_version_absence",
+        action="store_true",
+        help="Allow unversioned cachefiles to be converted.",
+    )
+    convert.set_defaults(func=cli_convert)
+
+    t4 = sp.add_parser("t4", help="Convert a cache file to the T4 auto-tuning format.")
+    t4.add_argument("--in", "--infile", required=True, help="The input cache file to read from.", dest="infile")
+    t4.add_argument("--out", "--output", required=True, help="The output JSON file to write to.", dest="output")
+    t4.set_defaults(func=cli_t4)
+
+    delete = sp.add_parser("delete-line", help="Delete a certain cacheline entry from the specified cachefile.")
+    delete.add_argument("infile", nargs=1, help="The input file to delete from.")
+    delete.add_argument(
+        "--key", required=True, help="The (potential) key of the (potential) cacheline entry to delete."
+    )
+    delete.add_argument(
+        "-o", "--out", "--output", help="The (optional) output file to write the updated cachefile to.", dest="output"
+    )
+    delete.set_defaults(func=cli_delete_line)
+
+    get = sp.add_parser("get-line", help="Get a certain cacheline entry from the specified cachefile.")
+    get.add_argument("infile", nargs=1, help="The input file to check.")
+    get.add_argument("--key", required=True, help="The (potential) key of the (potential) cacheline entry to get.")
+    get.set_defaults(func=cli_getline)
+
+    merge = sp.add_parser("merge", help="Merge two or more cachefiles.")
+    merge.add_argument(
+        "files",
+        nargs="+",
+        help="The cachefiles to merge (minimum two). They must be of the same version, and "
+        "contain equivalent metadata.",
+    )
+    merge.add_argument(
+        "-o",
+        "--out",
+        "--output",
+        required=True,
+        help="The output file to write the merged cachefiles to.",
+        dest="output",
+    )
+    merge.set_defaults(func=cli_merge)
+
+    # Parse input and call the appropiate function.
+    return parser.parse_args(args)
+
+
+def main():
+    """The function called when running the cli. This function calls the main parsing function.
+
+    This is one of {convert, delete-line, get-line, merge, t4},
+    based on this the appropiate function cli_{convert, delete-line, get-line, merge, t4} is called.
+    """
+    parser = parse_args(sys.argv[1:])
+
+    parser.func(parser)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/kernel_tuner/strategies/bayes_opt.py b/kernel_tuner/strategies/bayes_opt.py
index bd20e29a9..ae498683f 100644
--- a/kernel_tuner/strategies/bayes_opt.py
+++ b/kernel_tuner/strategies/bayes_opt.py
@@ -235,7 +235,7 @@ def get_hyperparam(name: str, default, supported_values=list()):
         self.invalid_value = 1e20
         self.opt_direction = opt_direction
         if opt_direction == "min":
-            self.worst_value = np.PINF
+            self.worst_value = np.inf
             self.argopt = np.argmin
         elif opt_direction == "max":
             self.worst_value = np.NINF
diff --git a/kernel_tuner/strategies/common.py b/kernel_tuner/strategies/common.py
index d01eae937..456811148 100644
--- a/kernel_tuner/strategies/common.py
+++ b/kernel_tuner/strategies/common.py
@@ -109,7 +109,9 @@ def __call__(self, x, check_restrictions=True):
             self.runner.last_strategy_start_time = perf_counter()
 
         # get numerical return value, taking optimization direction into account
-        return_value = result[self.tuning_options.objective] or sys.float_info.max
+        return_value = result[self.tuning_options.objective]
+        if isinstance(return_value, util.ErrorConfig) or not return_value:
+            return_value = sys.float_info.max
         return_value = return_value if not self.tuning_options.objective_higher_is_better else -return_value
 
         return return_value
diff --git a/kernel_tuner/util.py b/kernel_tuner/util.py
index 0d2cef696..85fd638a7 100644
--- a/kernel_tuner/util.py
+++ b/kernel_tuner/util.py
@@ -30,6 +30,7 @@
 )
 
 from kernel_tuner.accuracy import Tunable
+from kernel_tuner.cache.cache import Cache
 
 try:
     import cupy as cp
@@ -45,7 +46,14 @@
 # number of special values to insert when a configuration cannot be measured
 
 
-class ErrorConfig(str):
+class ErrorConfig:
+    @classmethod
+    def from_str(cls, name: str):
+        """Creates an ErrorConfig subclass whieh has name ``name``."""
+        for SubClass in cls.__subclasses__():
+            if SubClass.__name__ == name:
+                return SubClass()
+
     def __str__(self):
         return self.__class__.__name__
 
@@ -1107,49 +1115,42 @@ def process_cache(cache, kernel_options, tuning_options, runner):
                 f"Simulation mode requires an existing cachefile: file {cache} does not exist"
             )
 
-        c = dict()
-        c["device_name"] = runner.dev.name
-        c["kernel_name"] = kernel_options.kernel_name
-        c["problem_size"] = (
-            kernel_options.problem_size
-            if not callable(kernel_options.problem_size)
-            else "callable"
+        c = Cache.create(
+            filename=cache,
+            device_name=runner.dev.name,
+            kernel_name=kernel_options.kernel_name,
+            problem_size=(
+                kernel_options.problem_size
+                if not callable(kernel_options.problem_size)
+                else "callable"
+            ),
+            tune_params_keys=list(tuning_options.tune_params.keys()),
+            tune_params=tuning_options.tune_params,
+            objective=tuning_options.objective
         )
-        c["tune_params_keys"] = list(tuning_options.tune_params.keys())
-        c["tune_params"] = tuning_options.tune_params
-        c["objective"] = tuning_options.objective
-        c["cache"] = {}
-
-        contents = json.dumps(c, cls=NpEncoder, indent="")[:-3]  # except the last "}\n}"
-
-        # write the header to the cachefile
-        with open(cache, "w") as cachefile:
-            cachefile.write(contents)
-
-        tuning_options.cachefile = cache
-        tuning_options.cache = {}
 
     # if file exists
     else:
-        cached_data = read_cache(cache)
+        # Read existing cache file, when using simulation_mode file is treated read_only
+        c = Cache.read(cache, read_only=tuning_options.simulation_mode)
 
         # if in simulation mode, use the device name from the cache file as the runner device name
         if runner.simulation_mode:
-            runner.dev.name = cached_data["device_name"]
+            runner.dev.name = c.device_name
 
         # check if it is safe to continue tuning from this cache
-        if cached_data["device_name"] != runner.dev.name:
+        if c.device_name != runner.dev.name:
             raise ValueError(
                 "Cannot load cache which contains results for different device"
             )
-        if cached_data["kernel_name"] != kernel_options.kernel_name:
+        if c.kernel_name != kernel_options.kernel_name:
             raise ValueError(
                 "Cannot load cache which contains results for different kernel"
             )
-        if "problem_size" in cached_data and not callable(kernel_options.problem_size):
+        if not callable(kernel_options.problem_size):
             # if problem_size is not iterable, compare directly
             if not hasattr(kernel_options.problem_size, "__iter__"):
-                if cached_data["problem_size"] != kernel_options.problem_size:
+                if c.problem_size != kernel_options.problem_size:
                     raise ValueError(
                         "Cannot load cache which contains results for different problem_size"
                     )
@@ -1160,105 +1161,27 @@ def process_cache(cache, kernel_options, tuning_options, runner):
                 [
                     i == j
                     for i, j in zip(
-                        cached_data["problem_size"], kernel_options.problem_size
+                        c.problem_size, kernel_options.problem_size
                     )
                 ]
             ):
                 raise ValueError(
                     "Cannot load cache which contains results for different problem_size"
                 )
-        if cached_data["tune_params_keys"] != list(tuning_options.tune_params.keys()):
-            if all(key in tuning_options.tune_params for key in cached_data["tune_params_keys"]):
+        if c.tune_params_keys != list(tuning_options.tune_params.keys()):
+            if all(key in tuning_options.tune_params for key in c.tune_params_keys):
                 raise ValueError(
                     f"All tunable parameters are present, but the order is wrong. \
                     This is not possible because the order must be preserved to lookup the correct configuration in the cache. \
-                    Cache has order: {cached_data['tune_params_keys']}, tuning_options has: {list(tuning_options.tune_params.keys())}"
+                    Cache has order: {c.tune_params_keys}, tuning_options has: {list(tuning_options.tune_params.keys())}"
                 )
             raise ValueError(
                 f"Cannot load cache which contains results obtained with different tunable parameters. \
-                Cache has: {cached_data['tune_params_keys']}, tuning_options has: {list(tuning_options.tune_params.keys())}"
+                Cache has: {c.tune_params_keys}, tuning_options has: {list(tuning_options.tune_params.keys())}"
             )
 
-        tuning_options.cachefile = cache
-        tuning_options.cache = cached_data["cache"]
-
-
-def correct_open_cache(cache, open_cache=True):
-    """If cache file was not properly closed, pretend it was properly closed."""
-    with open(cache, "r") as cachefile:
-        filestr = cachefile.read().strip()
-
-    # if file was not properly closed, pretend it was properly closed
-    if len(filestr) > 0 and not filestr[-3:] in ["}\n}", "}}}"]:
-        # remove the trailing comma if any, and append closing brackets
-        if filestr[-1] == ",":
-            filestr = filestr[:-1]
-        if len(filestr) > 0:
-            filestr = filestr + "}\n}"
-    else:
-        if open_cache:
-            # if it was properly closed, open it for appending new entries
-            with open(cache, "w") as cachefile:
-                cachefile.write(filestr[:-3] + ",")
-
-    return filestr
-
-def read_cache(cache, open_cache=True):
-    """Read the cachefile into a dictionary, if open_cache=True prepare the cachefile for appending."""
-    filestr = correct_open_cache(cache, open_cache)
-
-    error_configs = {
-        "InvalidConfig": InvalidConfig(),
-        "CompilationFailedConfig": CompilationFailedConfig(),
-        "RuntimeFailedConfig": RuntimeFailedConfig(),
-    }
-
-    # replace strings with ErrorConfig instances
-    cache_data = json.loads(filestr)
-    for element in cache_data["cache"].values():
-        for k, v in element.items():
-            if isinstance(v, str) and v in error_configs:
-                element[k] = error_configs[v]
-
-    return cache_data
-
-
-def close_cache(cache):
-    if not os.path.isfile(cache):
-        raise ValueError("close_cache expects cache file to exist")
-
-    with open(cache, "r") as fh:
-        contents = fh.read()
-
-    # close to file to make sure it can be read by JSON parsers
-    if contents[-1] == ",":
-        with open(cache, "w") as fh:
-            fh.write(contents[:-1] + "}\n}")
-
-
-def store_cache(key, params, tuning_options):
-    """Stores a new entry (key, params) to the cachefile."""
-    # logging.debug('store_cache called, cache=%s, cachefile=%s' % (tuning_options.cache, tuning_options.cachefile))
-    if isinstance(tuning_options.cache, dict):
-        if key not in tuning_options.cache:
-            tuning_options.cache[key] = params
-
-            # Convert ErrorConfig objects to string, wanted to do this inside the JSONconverter but couldn't get it to work
-            output_params = params.copy()
-            for k, v in output_params.items():
-                if isinstance(v, ErrorConfig):
-                    output_params[k] = str(v)
-
-            if tuning_options.cachefile:
-                with open(tuning_options.cachefile, "a") as cachefile:
-                    cachefile.write("\n" + json.dumps({key: output_params}, cls=NpEncoder)[1:-1] + ",")
-
-
-def dump_cache(obj: str, tuning_options):
-    """Dumps a string in the cache, this omits the several checks of store_cache() to speed up the process - with great power comes great responsibility!"""
-    if isinstance(tuning_options.cache, dict) and tuning_options.cachefile:
-        with open(tuning_options.cachefile, "a") as cachefile:
-            cachefile.write(obj)
+    tuning_options.cachefile = cache
+    tuning_options.cache = c.lines
 
 
 def cuda_error_check(error):
diff --git a/pyproject.toml b/pyproject.toml
index 3175ed34a..654976351 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,7 +57,7 @@ generate-setup-file = false
 # ATTENTION: if anything is changed here, run `poetry update`
 [tool.poetry.dependencies]
 python = ">=3.9,<3.13"          # NOTE when changing the supported Python versions, also change the test versions in the noxfile
-numpy = ">=1.26.0"              # Python 3.12 requires numpy at least 1.26
+numpy = "^1.26.0"               # Python 3.12 requires numpy at least 1.26
 scipy = ">=1.11.0"
 packaging = "*"                 # required by file_utils
 jsonschema = "*"
@@ -65,6 +65,7 @@ python-constraint2 = "^2.0.0b5"
 xmltodict = "*"
 pandas = ">=2.0.0"
 scikit-learn = ">=1.0.2"
+semver = ">=3.0.0"
 # Torch can be used with Kernel Tuner, but is not a dependency, should be up to the user to use it
 
 # List of optional dependencies for user installation, e.g. `pip install kernel_tuner[cuda]`, used in the below `extras`.
@@ -144,3 +145,6 @@ select = [
 ]
 [tool.ruff.pydocstyle]
 convention = "google"
+
+[tool.poetry.scripts]
+"ktcache" = "kernel_tuner.scripts.ktcache:main"
diff --git a/test/ruff.toml b/test/ruff.toml
new file mode 100644
index 000000000..dcb3ac95f
--- /dev/null
+++ b/test/ruff.toml
@@ -0,0 +1,2 @@
+extend = "../pyproject.toml"
+ignore = ["D100", "D101", "D102", "D103"]
diff --git a/test/strategies/test_bayesian_optimization.py b/test/strategies/test_bayesian_optimization.py
index dd206a37b..8d929054a 100644
--- a/test/strategies/test_bayesian_optimization.py
+++ b/test/strategies/test_bayesian_optimization.py
@@ -74,7 +74,7 @@ def test_bo_initialization():
     assert BO.searchspace == pruned_parameter_space
     assert BO.unvisited_cache == pruned_parameter_space
     assert len(BO.observations) == len(pruned_parameter_space)
-    assert BO.current_optimum == np.PINF
+    assert BO.current_optimum == np.inf
 
 def test_bo_initial_sample_lhs():
     sample = BO.draw_latin_hypercube_samples(num_samples=1)
diff --git a/test/synthetic_fp32_cache_NVIDIA_RTX_A4000.json b/test/synthetic_fp32_cache_NVIDIA_RTX_A4000.json
index 2ea169d82..3b2935854 100644
--- a/test/synthetic_fp32_cache_NVIDIA_RTX_A4000.json
+++ b/test/synthetic_fp32_cache_NVIDIA_RTX_A4000.json
@@ -34,15 +34,18 @@
 405
 ]
 },
+"schema_version": "1.0.0",
+"objective": "time",
 "cache": {
-"1024,64,1024,2100": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 2100, "core_freq": 1739.7175427234456, "time": 77.53778305053712, "times": [75.01824188232422, 78.39437103271484, 77.64275360107422, 77.55980682373047, 77.51065826416016, 77.77279663085938, 77.90386962890625, 77.73798370361328, 78.08905792236328, 77.748291015625], "pwr_core_freq": 1722.6449009537785, "nvml_power": 139.161, "compile_time": 3950.955282896757, "verification_time": 0, "benchmark_time": 1796.9796061515808, "f": 1739.7175427234456, "strategy_time": 0, "framework_time": 2.5989077985286713},
-"1024,64,1024,1905": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1905, "core_freq": 1752.1604878240541, "time": 76.95706253051758, "times": [74.33216094970703, 77.56800079345703, 77.43180847167969, 77.14498901367188, 77.5198745727539, 76.99967956542969, 76.99763488769531, 77.12767791748047, 77.14508819580078, 77.3037109375], "pwr_core_freq": 1731.5070093457944, "nvml_power": 138.871, "compile_time": 3948.057930916548, "verification_time": 0, "benchmark_time": 2191.8914653360844, "f": 1752.1604878240541, "strategy_time": 0, "framework_time": 1.8665380775928497},
-"1024,64,1024,1710": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1710, "core_freq": 1710.0, "time": 78.82117233276367, "times": [78.94528198242188, 78.84595489501953, 78.80601501464844, 78.80397033691406, 78.79987335205078, 78.82546997070312, 78.79373168945312, 78.79065704345703, 78.80089569091797, 78.79987335205078], "pwr_core_freq": 1710.0, "nvml_power": 133.824, "compile_time": 3941.864926367998, "verification_time": 0, "benchmark_time": 2163.301534950733, "f": 1710.0, "strategy_time": 0, "framework_time": 1.9937194883823395},
-"1024,64,1024,1530": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1530, "core_freq": 1530.0, "time": 88.1852409362793, "times": [88.99378967285156, 88.22271728515625, 88.0711669921875, 88.07730865478516, 88.07014465332031, 88.06400299072266, 88.07936096191406, 88.1244125366211, 88.0732192993164, 88.07628631591797], "pwr_core_freq": 1530.0, "nvml_power": 103.031, "compile_time": 3972.328145056963, "verification_time": 0, "benchmark_time": 2333.6658142507076, "f": 1530.0, "strategy_time": 0, "framework_time": 1.7150826752185822},
-"1024,64,1024,1335": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1335, "core_freq": 1335.0, "time": 100.94090194702149, "times": [101.01964569091797, 100.91929626464844, 100.92953491210938, 100.92031860351562, 100.93772888183594, 100.93260955810547, 100.9438705444336, 100.93465423583984, 100.9438705444336, 100.927490234375], "pwr_core_freq": 1335.0, "nvml_power": 79.923, "compile_time": 3961.2973630428314, "verification_time": 0, "benchmark_time": 2362.926233559847, "f": 1335.0, "strategy_time": 0, "framework_time": 2.0712725818157196},
-"1024,64,1024,1155": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1155, "core_freq": 1155.0, "time": 116.66185607910157, "times": [116.74111938476562, 116.66124725341797, 116.66226959228516, 116.63359832763672, 116.66124725341797, 116.65299224853516, 116.63359832763672, 116.66329956054688, 116.66944122314453, 116.6397476196289], "pwr_core_freq": 1155.0, "nvml_power": 72.241, "compile_time": 3956.4162008464336, "verification_time": 0, "benchmark_time": 2606.1498671770096, "f": 1155.0, "strategy_time": 0, "framework_time": 1.7136447131633759},
-"1024,64,1024,960": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 960, "core_freq": 960.0, "time": 140.37103271484375, "times": [140.4620819091797, 140.3555145263672, 140.36480712890625, 140.35353088378906, 140.3934783935547, 140.39859008789062, 140.33920288085938, 140.37298583984375, 140.31666564941406, 140.3534698486328], "pwr_core_freq": 960.0, "nvml_power": 65.004, "compile_time": 3970.390599220991, "verification_time": 0, "benchmark_time": 2920.069545507431, "f": 960.0, "strategy_time": 0, "framework_time": 2.164263278245926},
-"1024,64,1024,780": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 780, "core_freq": 780.0, "time": 172.72442779541015, "times": [172.832763671875, 172.7651824951172, 172.6945343017578, 172.71192932128906, 172.7139892578125, 172.71192932128906, 172.71090698242188, 172.7262725830078, 172.70375061035156, 172.6730194091797], "pwr_core_freq": 780.0, "nvml_power": 58.972, "compile_time": 3970.3225307166576, "verification_time": 0, "benchmark_time": 3119.3020306527615, "f": 780.0, "strategy_time": 0, "framework_time": 1.7446689307689667},
-"1024,64,1024,585": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 585, "core_freq": 585.0, "time": 230.3109100341797, "times": [230.466552734375, 230.2566375732422, 230.37440490722656, 230.35186767578125, 230.26585388183594, 230.2678985595703, 230.2228546142578, 230.27711486816406, 230.35903930664062, 230.26687622070312], "pwr_core_freq": 585.0, "nvml_power": 52.095, "compile_time": 3952.59528234601, "verification_time": 0, "benchmark_time": 3827.805496752262, "f": 585.0, "strategy_time": 0, "framework_time": 1.6073323786258698},
-"1024,64,1024,405": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 405, "core_freq": 405.0, "time": 332.58628845214844, "times": [332.5245361328125, 332.55218505859375, 332.5777893066406, 332.6330871582031, 332.60748291015625, 332.5696105957031, 332.5962219238281, 332.6740417480469, 332.5317077636719, 332.5962219238281], "pwr_core_freq": 405.0, "nvml_power": 43.928, "compile_time": 3988.419521600008, "verification_time": 0, "benchmark_time": 5038.08306902647, "f": 405.0, "strategy_time": 0, "framework_time": 1.7108693718910217}}
+"1024,64,1024,2100": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 2100, "core_freq": 1739.7175427234456, "time": 77.53778305053712, "times": [75.01824188232422, 78.39437103271484, 77.64275360107422, 77.55980682373047, 77.51065826416016, 77.77279663085938, 77.90386962890625, 77.73798370361328, 78.08905792236328, 77.748291015625], "pwr_core_freq": 1722.6449009537785, "nvml_power": 139.161, "compile_time": 3950.955282896757, "verification_time": 0, "benchmark_time": 1796.9796061515808, "f": 1739.7175427234456, "strategy_time": 0, "framework_time": 2.5989077985286713, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,1905": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1905, "core_freq": 1752.1604878240541, "time": 76.95706253051758, "times": [74.33216094970703, 77.56800079345703, 77.43180847167969, 77.14498901367188, 77.5198745727539, 76.99967956542969, 76.99763488769531, 77.12767791748047, 77.14508819580078, 77.3037109375], "pwr_core_freq": 1731.5070093457944, "nvml_power": 138.871, "compile_time": 3948.057930916548, "verification_time": 0, "benchmark_time": 2191.8914653360844, "f": 1752.1604878240541, "strategy_time": 0, "framework_time": 1.8665380775928497, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,1710": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1710, "core_freq": 1710.0, "time": 78.82117233276367, "times": [78.94528198242188, 78.84595489501953, 78.80601501464844, 78.80397033691406, 78.79987335205078, 78.82546997070312, 78.79373168945312, 78.79065704345703, 78.80089569091797, 78.79987335205078], "pwr_core_freq": 1710.0, "nvml_power": 133.824, "compile_time": 3941.864926367998, "verification_time": 0, "benchmark_time": 2163.301534950733, "f": 1710.0, "strategy_time": 0, "framework_time": 1.9937194883823395, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,1530": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1530, "core_freq": 1530.0, "time": 88.1852409362793, "times": [88.99378967285156, 88.22271728515625, 88.0711669921875, 88.07730865478516, 88.07014465332031, 88.06400299072266, 88.07936096191406, 88.1244125366211, 88.0732192993164, 88.07628631591797], "pwr_core_freq": 1530.0, "nvml_power": 103.031, "compile_time": 3972.328145056963, "verification_time": 0, "benchmark_time": 2333.6658142507076, "f": 1530.0, "strategy_time": 0, "framework_time": 1.7150826752185822, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,1335": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1335, "core_freq": 1335.0, "time": 100.94090194702149, "times": [101.01964569091797, 100.91929626464844, 100.92953491210938, 100.92031860351562, 100.93772888183594, 100.93260955810547, 100.9438705444336, 100.93465423583984, 100.9438705444336, 100.927490234375], "pwr_core_freq": 1335.0, "nvml_power": 79.923, "compile_time": 3961.2973630428314, "verification_time": 0, "benchmark_time": 2362.926233559847, "f": 1335.0, "strategy_time": 0, "framework_time": 2.0712725818157196, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,1155": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 1155, "core_freq": 1155.0, "time": 116.66185607910157, "times": [116.74111938476562, 116.66124725341797, 116.66226959228516, 116.63359832763672, 116.66124725341797, 116.65299224853516, 116.63359832763672, 116.66329956054688, 116.66944122314453, 116.6397476196289], "pwr_core_freq": 1155.0, "nvml_power": 72.241, "compile_time": 3956.4162008464336, "verification_time": 0, "benchmark_time": 2606.1498671770096, "f": 1155.0, "strategy_time": 0, "framework_time": 1.7136447131633759, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,960": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 960, "core_freq": 960.0, "time": 140.37103271484375, "times": [140.4620819091797, 140.3555145263672, 140.36480712890625, 140.35353088378906, 140.3934783935547, 140.39859008789062, 140.33920288085938, 140.37298583984375, 140.31666564941406, 140.3534698486328], "pwr_core_freq": 960.0, "nvml_power": 65.004, "compile_time": 3970.390599220991, "verification_time": 0, "benchmark_time": 2920.069545507431, "f": 960.0, "strategy_time": 0, "framework_time": 2.164263278245926, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,780": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 780, "core_freq": 780.0, "time": 172.72442779541015, "times": [172.832763671875, 172.7651824951172, 172.6945343017578, 172.71192932128906, 172.7139892578125, 172.71192932128906, 172.71090698242188, 172.7262725830078, 172.70375061035156, 172.6730194091797], "pwr_core_freq": 780.0, "nvml_power": 58.972, "compile_time": 3970.3225307166576, "verification_time": 0, "benchmark_time": 3119.3020306527615, "f": 780.0, "strategy_time": 0, "framework_time": 1.7446689307689667, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,585": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 585, "core_freq": 585.0, "time": 230.3109100341797, "times": [230.466552734375, 230.2566375732422, 230.37440490722656, 230.35186767578125, 230.26585388183594, 230.2678985595703, 230.2228546142578, 230.27711486816406, 230.35903930664062, 230.26687622070312], "pwr_core_freq": 585.0, "nvml_power": 52.095, "compile_time": 3952.59528234601, "verification_time": 0, "benchmark_time": 3827.805496752262, "f": 585.0, "strategy_time": 0, "framework_time": 1.6073323786258698, "timestamp": "2024-06-18 11:36:56.137831+00:00"},
+"1024,64,1024,405": {"block_size_x": 1024, "nr_outer": 64, "nr_inner": 1024, "nvml_gr_clock": 405, "core_freq": 405.0, "time": 332.58628845214844, "times": [332.5245361328125, 332.55218505859375, 332.5777893066406, 332.6330871582031, 332.60748291015625, 332.5696105957031, 332.5962219238281, 332.6740417480469, 332.5317077636719, 332.5962219238281], "pwr_core_freq": 405.0, "nvml_power": 43.928, "compile_time": 3988.419521600008, "verification_time": 0, "benchmark_time": 5038.08306902647, "f": 405.0, "strategy_time": 0, "framework_time": 1.7108693718910217, "timestamp": "2024-06-18 11:36:56.137831+00:00"}
+}
 }
\ No newline at end of file
diff --git a/test/test_cache_file.json b/test/test_cache_file.json
index 3299441c5..aa718de4c 100644
--- a/test/test_cache_file.json
+++ b/test/test_cache_file.json
@@ -1,6 +1,8 @@
 {
+    "schema_version": "1.0.0",
     "device_name": "NVIDIA RTX A4000",
     "kernel_name": "vector_add",
+    "problem_size": 100,
     "tune_params_keys": [
         "block_size_x"
     ],
@@ -23,6 +25,7 @@
             1024
         ]
     },
+    "objective": "time",
     "cache": {
         "128": {
             "block_size_x": 128,
diff --git a/test/test_cache_files/large_cache.json b/test/test_cache_files/large_cache.json
new file mode 100644
index 000000000..dc23a8f76
--- /dev/null
+++ b/test/test_cache_files/large_cache.json
@@ -0,0 +1,534 @@
+{
+"schema_version": "1.0.0",
+"device_name": "",
+"kernel_name": "convolution_kernel",
+"problem_size": [
+4096,
+4096
+],
+"tune_params_keys": [
+"block_size_x",
+"block_size_y",
+"tile_size_x",
+"tile_size_y",
+"read_only",
+"use_padding",
+"use_shmem",
+"use_cmem",
+"filter_height",
+"filter_width"
+],
+"tune_params": {
+"block_size_x": [
+16,
+32,
+48,
+64,
+80,
+96,
+112,
+128,
+144,
+160,
+176,
+192,
+208,
+224,
+240,
+256
+],
+"block_size_y": [
+1,
+2,
+4,
+8,
+16
+],
+"tile_size_x": [
+1,
+2,
+3,
+4
+],
+"tile_size_y": [
+1,
+2,
+3,
+4
+],
+"read_only": [
+0,
+1
+],
+"use_padding": [
+0,
+1
+],
+"use_shmem": [
+0,
+1
+],
+"use_cmem": [
+1
+],
+"filter_height": [
+15
+],
+"filter_width": [
+15
+]
+},
+"objective": "time",
+"cache": {
+"16,1,1,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.262957006692886, "times": [12.265098571777344, 12.252779960632324, 12.25790023803711, 12.253418922424316, 12.254219055175781, 12.26366138458252, 12.251818656921387, 12.264618873596191, 12.252618789672852, 12.257740020751953, 12.259658813476562, 12.253725051879883, 12.257899284362793, 12.25325870513916, 12.25629997253418, 12.25309944152832, 12.258379936218262, 12.264481544494629, 12.258378982543945, 12.258858680725098, 12.262378692626953, 12.257099151611328, 12.256779670715332, 12.256739616394043, 12.260458946228027, 12.431501388549805, 12.259498596191406, 12.259979248046875, 12.256778717041016, 12.259296417236328, 12.254538536071777, 12.251660346984863], "compile_time": 661.5392221137881, "verification_time": 0, "benchmark_time": 393.9172066748142, "GFLOP/s": 615.6547067627729, "strategy_time": 0, "framework_time": 53.12582431361079, "timestamp": "2023-12-21 10:44:42.236642+00:00"},
+"16,1,1,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.34145200252533, "times": [12.3654203414917, 12.343340873718262, 12.343339920043945, 12.333259582519531, 12.340140342712402, 12.33586597442627, 12.343819618225098, 12.345100402832031, 12.347339630126953, 12.335659980773926, 12.335020065307617, 12.340396881103516, 12.344301223754883, 12.343339920043945, 12.338540077209473, 12.341899871826172, 12.336939811706543, 12.336755752563477, 12.351180076599121, 12.339981079101562, 12.349579811096191, 12.340940475463867, 12.33950138092041, 12.340375900268555, 12.334859848022461, 12.340780258178711, 12.34990119934082, 12.33981990814209, 12.345900535583496, 12.332321166992188, 12.339020729064941, 12.33182144165039], "compile_time": 326.4552033506334, "verification_time": 0, "benchmark_time": 396.81255631148815, "GFLOP/s": 611.7389751590945, "strategy_time": 0, "framework_time": 2.972428221255541, "timestamp": "2023-12-21 10:44:42.962940+00:00"},
+"16,1,1,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.346593052148819, "times": [12.3654203414917, 12.346540451049805, 12.358381271362305, 12.346381187438965, 12.34398078918457, 12.343509674072266, 12.345260620117188, 12.344301223754883, 12.342540740966797, 12.344301223754883, 12.342540740966797, 12.343490600585938, 12.339659690856934, 12.34286117553711, 12.347981452941895, 12.344941139221191, 12.341421127319336, 12.346572875976562, 12.344940185546875, 12.34749984741211, 12.346059799194336, 12.355500221252441, 12.350700378417969, 12.345030784606934, 12.342860221862793, 12.341580390930176, 12.34253978729248, 12.3468599319458, 12.3489408493042, 12.349058151245117, 12.34589958190918, 12.353421211242676], "compile_time": 326.4245339669287, "verification_time": 0, "benchmark_time": 396.92616602405906, "GFLOP/s": 611.4842506035324, "strategy_time": 0, "framework_time": 0.9948583319783211, "timestamp": "2023-12-21 10:44:43.687302+00:00"},
+"16,1,1,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.64582659304142, "times": [6.8259968757629395, 6.642314910888672, 6.634634971618652, 6.642955780029297, 6.641036033630371, 6.633676052093506, 6.641036033630371, 6.649355888366699, 6.6363959312438965, 6.640420913696289, 6.63639497756958, 6.641194820404053, 6.6383161544799805, 6.644714832305908, 6.638315200805664, 6.640554904937744, 6.638155937194824, 6.639434814453125, 6.643276214599609, 6.637413024902344, 6.637355804443359, 6.642475128173828, 6.6424760818481445, 6.634955883026123, 6.6405558586120605, 6.63783597946167, 6.640875816345215, 6.638794898986816, 6.641836166381836, 6.640024185180664, 6.6399149894714355, 6.643755912780762], "compile_time": 345.7579957321286, "verification_time": 0, "benchmark_time": 213.88119040057063, "GFLOP/s": 1136.013270027996, "strategy_time": 0, "framework_time": 0.7923957891762257, "timestamp": "2023-12-21 10:44:44.247748+00:00"},
+"16,1,1,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.3233422935009, "times": [12.34749984741211, 12.323980331420898, 12.322699546813965, 12.320619583129883, 12.322220802307129, 12.318915367126465, 12.322219848632812, 12.318699836730957, 12.325579643249512, 12.32318115234375, 12.316940307617188, 12.316546440124512, 12.320940017700195, 12.318059921264648, 12.31566047668457, 12.316780090332031, 12.320940017700195, 12.32703685760498, 12.320779800415039, 12.32013988494873, 12.338220596313477, 12.320460319519043, 12.32158088684082, 12.3276948928833, 12.32334041595459, 12.32446002960205, 12.3185396194458, 12.327659606933594, 12.31742000579834, 12.334737777709961, 12.322859764099121, 12.33053970336914], "compile_time": 323.3141880482435, "verification_time": 0, "benchmark_time": 395.8132811821997, "GFLOP/s": 612.6379532589625, "strategy_time": 0, "framework_time": 1.3811048120260239, "timestamp": "2023-12-21 10:44:44.968272+00:00"},
+"16,1,1,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.332039475440979, "times": [12.349419593811035, 12.330221176147461, 12.320619583129883, 12.327659606933594, 12.319499969482422, 12.324612617492676, 12.32446002960205, 12.32509994506836, 12.328620910644531, 12.504623413085938, 12.326700210571289, 12.323296546936035, 12.325260162353516, 12.322699546813965, 12.331979751586914, 12.327980041503906, 12.324620246887207, 12.327615737915039, 12.32942008972168, 12.329899787902832, 12.32334041595459, 12.326539993286133, 12.323019981384277, 12.325926780700684, 12.32349967956543, 12.327980995178223, 12.329099655151367, 12.326539993286133, 12.324139595031738, 12.324187278747559, 12.312620162963867, 12.334059715270996], "compile_time": 323.7900398671627, "verification_time": 0, "benchmark_time": 396.21788496151567, "GFLOP/s": 612.2058897909933, "strategy_time": 0, "framework_time": 1.1702780611813068, "timestamp": "2023-12-21 10:44:45.689466+00:00"},
+"16,1,1,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.6253343299031258, "times": [3.6472411155700684, 3.6226019859313965, 3.6462810039520264, 3.619720935821533, 3.6190810203552246, 3.617002010345459, 3.617640972137451, 3.6400411128997803, 3.6206820011138916, 3.6202011108398438, 3.616520881652832, 3.6374809741973877, 3.644521951675415, 3.625641107559204, 3.6202011108398438, 3.640681028366089, 3.6208410263061523, 3.62253999710083, 3.6187610626220703, 3.619400978088379, 3.619882106781006, 3.622441053390503, 3.619720935821533, 3.6416409015655518, 3.6258020401000977, 3.620521068572998, 3.6190810203552246, 3.619720935821533, 3.6189210414886475, 3.6211609840393066, 3.621320962905884, 3.6234021186828613], "compile_time": 413.3805222809315, "verification_time": 0, "benchmark_time": 117.44891619309783, "GFLOP/s": 2082.496816287214, "strategy_time": 0, "framework_time": 1.3593826442956924, "timestamp": "2023-12-21 10:44:46.221670+00:00"},
+"16,1,1,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.656750321388245, "times": [6.679755210876465, 6.649835109710693, 6.64823579788208, 6.658155918121338, 6.649995803833008, 6.647435188293457, 6.646796226501465, 6.64983606338501, 6.650794982910156, 6.648237228393555, 6.653515815734863, 6.647755146026611, 6.656235218048096, 6.651275157928467, 6.64599609375, 6.645835876464844, 6.64679479598999, 6.646315097808838, 6.816718101501465, 6.652376174926758, 6.652875900268555, 6.65415620803833, 6.647914886474609, 6.653835773468018, 6.648076057434082, 6.650795936584473, 6.653835773468018, 6.65415620803833, 6.648715972900391, 6.655760765075684, 6.651916027069092, 6.65207576751709], "compile_time": 371.418665163219, "verification_time": 0, "benchmark_time": 214.51672166585922, "GFLOP/s": 1134.1490720693762, "strategy_time": 0, "framework_time": 1.3851621188223362, "timestamp": "2023-12-21 10:44:46.809008+00:00"},
+"16,1,1,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.655352085828781, "times": [6.680075168609619, 6.654315948486328, 6.653515815734863, 6.656556129455566, 6.651275157928467, 6.652875900268555, 6.649355888366699, 6.658155918121338, 6.655275821685791, 6.650475025177002, 6.655914783477783, 6.666316032409668, 6.651115894317627, 6.656075954437256, 6.65415620803833, 6.650634765625, 6.6560750007629395, 6.655435085296631, 6.6536760330200195, 6.653504848480225, 6.657354831695557, 6.653995990753174, 6.655436038970947, 6.657835960388184, 6.651275157928467, 6.657674789428711, 6.64983606338501, 6.654476165771484, 6.652394771575928, 6.655333995819092, 6.65207576751709, 6.6587958335876465], "compile_time": 373.34413500502706, "verification_time": 0, "benchmark_time": 214.38566781580448, "GFLOP/s": 1134.3873476018873, "strategy_time": 0, "framework_time": 1.2402520515024662, "timestamp": "2023-12-21 10:44:47.397994+00:00"},
+"16,1,1,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.625722549855709, "times": [3.6474010944366455, 3.6240410804748535, 3.6178019046783447, 3.6168410778045654, 3.617480993270874, 3.6173219680786133, 3.6170010566711426, 3.6192409992218018, 3.6166810989379883, 3.619081974029541, 3.6238820552825928, 3.6229209899902344, 3.6221210956573486, 3.6181209087371826, 3.6187610626220703, 3.6195619106292725, 3.618601083755493, 3.6189610958099365, 3.6189210414886475, 3.6192409992218018, 3.6190810203552246, 3.618921995162964, 3.6250009536743164, 3.619400978088379, 3.624680995941162, 3.621320962905884, 3.620521068572998, 3.772202968597412, 3.6221210956573486, 3.6184420585632324, 3.6218008995056152, 3.625641107559204], "compile_time": 395.64133808016777, "verification_time": 0, "benchmark_time": 117.44928732514381, "GFLOP/s": 2082.273835404326, "strategy_time": 0, "framework_time": 1.4298586174845695, "timestamp": "2023-12-21 10:44:47.912528+00:00"},
+"16,1,1,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.63874888420105, "times": [6.66311502456665, 6.645036220550537, 6.650475978851318, 6.643595218658447, 6.6383161544799805, 6.635436058044434, 6.641995906829834, 6.641995906829834, 6.635756015777588, 6.634507179260254, 6.634955883026123, 6.63399600982666, 6.638474941253662, 6.636714935302734, 6.635916233062744, 6.635274887084961, 6.633835792541504, 6.6338348388671875, 6.637515068054199, 6.640456199645996, 6.6383161544799805, 6.638794898986816, 6.637034893035889, 6.633995056152344, 6.634634971618652, 6.640395164489746, 6.634154796600342, 6.641994953155518, 6.634954929351807, 6.642012119293213, 6.634955883026123, 6.637516021728516], "compile_time": 367.4304997548461, "verification_time": 0, "benchmark_time": 213.8350009918213, "GFLOP/s": 1137.2243975016063, "strategy_time": 0, "framework_time": 1.2861210852861404, "timestamp": "2023-12-21 10:44:48.495093+00:00"},
+"16,1,1,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.642681434750557, "times": [6.676074981689453, 6.640716075897217, 6.639756202697754, 6.639595985412598, 6.638956069946289, 6.635756015777588, 6.6359148025512695, 6.638794898986816, 6.642795085906982, 6.641703128814697, 6.63783597946167, 6.639276027679443, 6.642155170440674, 6.6405558586120605, 6.6424760818481445, 6.6407151222229, 6.649195194244385, 6.643115997314453, 6.64215612411499, 6.6388258934021, 6.64839506149292, 6.645356178283691, 6.640076160430908, 6.642315864562988, 6.639595985412598, 6.643596172332764, 6.645835876464844, 6.643916130065918, 6.640235900878906, 6.644041061401367, 6.646635055541992, 6.639435768127441], "compile_time": 367.58366599678993, "verification_time": 0, "benchmark_time": 213.90030719339848, "GFLOP/s": 1136.5511464247277, "strategy_time": 0, "framework_time": 1.4101010747253895, "timestamp": "2023-12-21 10:44:49.078002+00:00"},
+"16,1,1,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 91.15654587745667, "times": [91.41393280029297, 91.19730377197266, 91.22066497802734, 91.18396759033203, 91.27621459960938, 91.09488677978516, 91.13092803955078, 91.12933349609375, 91.13983154296875, 91.13188171386719, 91.15139770507812, 91.20086669921875, 91.17503356933594, 91.21188354492188, 91.14115142822266, 91.00557708740234, 91.02537536621094, 91.0839614868164, 91.08213806152344, 91.17733001708984, 91.08831787109375, 91.16560363769531, 91.19052124023438, 91.13909149169922, 91.17447662353516, 91.17793273925781, 91.14430236816406, 91.16617584228516, 91.1328125, 91.0850830078125, 91.1725845336914, 91.19890594482422], "compile_time": 3295.9692240692675, "verification_time": 0, "benchmark_time": 2918.696199078113, "GFLOP/s": 82.82177793517161, "strategy_time": 0, "framework_time": 1.3277227990329266, "timestamp": "2023-12-21 10:44:55.294011+00:00"},
+"16,1,1,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 23.1905876994133, "times": [23.38042640686035, 23.205385208129883, 23.183202743530273, 23.21994400024414, 23.139144897460938, 23.172067642211914, 23.121383666992188, 23.318187713623047, 23.290315628051758, 23.216903686523438, 23.09386444091797, 23.158172607421875, 23.088584899902344, 23.071624755859375, 23.249204635620117, 23.202823638916016, 23.18138313293457, 23.258132934570312, 23.155303955078125, 23.127944946289062, 23.221004486083984, 23.182024002075195, 23.187623977661133, 23.08723258972168, 23.24954605102539, 23.230186462402344, 23.168437957763672, 23.172903060913086, 23.19754409790039, 23.21977424621582, 23.155624389648438, 23.192903518676758], "compile_time": 422.3542641848326, "verification_time": 0, "benchmark_time": 743.4682017192245, "GFLOP/s": 325.55221531496596, "strategy_time": 0, "framework_time": 1.420781947672367, "timestamp": "2023-12-21 10:44:56.461270+00:00"},
+"16,1,1,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 23.38534814119339, "times": [23.43802833557129, 23.390188217163086, 23.357210159301758, 23.406347274780273, 23.363948822021484, 23.407129287719727, 23.393388748168945, 23.399627685546875, 23.40253257751465, 23.374507904052734, 23.386028289794922, 23.38364028930664, 23.34282875061035, 23.61018943786621, 23.37596321105957, 23.366668701171875, 23.38410758972168, 23.355939865112305, 23.405868530273438, 23.347627639770508, 23.375764846801758, 23.350187301635742, 23.337068557739258, 23.36451530456543, 23.380748748779297, 23.343788146972656, 23.388032913208008, 23.394668579101562, 23.37514877319336, 23.3909912109375, 23.35850715637207, 23.379947662353516], "compile_time": 422.78860695660114, "verification_time": 0, "benchmark_time": 749.9241572804749, "GFLOP/s": 322.84091536362837, "strategy_time": 0, "framework_time": 1.4146501198410988, "timestamp": "2023-12-21 10:44:57.635413+00:00"},
+"16,1,1,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 93.17676281929016, "times": [93.17304229736328, 93.13432312011719, 93.18128204345703, 93.25238037109375, 93.30612182617188, 93.29073333740234, 93.14704132080078, 93.11666107177734, 93.20463562011719, 93.27674865722656, 93.18463134765625, 93.25316619873047, 93.16700744628906, 93.09900665283203, 93.2696533203125, 93.17557525634766, 93.1313705444336, 93.24652862548828, 93.15238952636719, 93.099609375, 93.10369873046875, 93.11792755126953, 93.22509002685547, 93.08296203613281, 93.23306274414062, 93.1308364868164, 93.11367797851562, 93.16358947753906, 93.24441528320312, 93.14924621582031, 93.09878540039062, 93.13121032714844], "compile_time": 4188.3358135819435, "verification_time": 0, "benchmark_time": 2983.1490530632436, "GFLOP/s": 81.02607314918428, "strategy_time": 0, "framework_time": 1.3629812747240067, "timestamp": "2023-12-21 10:45:04.808276+00:00"},
+"16,1,1,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 22.93182098865509, "times": [23.22602653503418, 22.782339096069336, 22.971847534179688, 22.86890411376953, 22.989543914794922, 22.899303436279297, 22.965543746948242, 22.84682273864746, 23.04808235168457, 23.072423934936523, 22.993064880371094, 23.017860412597656, 22.930503845214844, 22.969383239746094, 22.968795776367188, 22.771299362182617, 22.550979614257812, 23.023096084594727, 22.75402069091797, 22.82490348815918, 22.728946685791016, 22.959623336791992, 22.825542449951172, 23.76099967956543, 22.735780715942383, 22.825061798095703, 22.91053581237793, 22.858821868896484, 22.959623336791992, 22.81934356689453, 22.995624542236328, 22.963623046875], "compile_time": 419.55884313210845, "verification_time": 0, "benchmark_time": 735.4665361344814, "GFLOP/s": 329.22580390519516, "strategy_time": 0, "framework_time": 1.4878013171255589, "timestamp": "2023-12-21 10:45:05.964807+00:00"},
+"16,1,1,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 23.337513327598572, "times": [23.382667541503906, 23.348907470703125, 23.329776763916016, 23.346187591552734, 23.319307327270508, 23.329591751098633, 23.353708267211914, 23.352428436279297, 23.336578369140625, 23.374187469482422, 23.362348556518555, 23.32677459716797, 23.35498809814453, 23.341388702392578, 23.32448387145996, 23.345867156982422, 23.34202766418457, 23.33415985107422, 23.294828414916992, 23.341707229614258, 23.298627853393555, 23.31642723083496, 23.308107376098633, 23.337547302246094, 23.330028533935547, 23.298828125, 23.362319946289062, 23.33610725402832, 23.346988677978516, 23.304912567138672, 23.358028411865234, 23.36058807373047], "compile_time": 418.27664989978075, "verification_time": 0, "benchmark_time": 748.3660727739334, "GFLOP/s": 323.5026411777895, "strategy_time": 0, "framework_time": 1.4829826541244984, "timestamp": "2023-12-21 10:45:07.132948+00:00"},
+"16,1,1,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.3227564319968224, "times": [2.3552260398864746, 2.3251469135284424, 2.3201870918273926, 2.326746940612793, 2.3310670852661133, 2.3221070766448975, 2.317786931991577, 2.319706916809082, 2.3225860595703125, 2.321787118911743, 2.3219470977783203, 2.3197059631347656, 2.321945905685425, 2.3203461170196533, 2.320986032485962, 2.317945957183838, 2.322906017303467, 2.3232269287109375, 2.3189070224761963, 2.3179469108581543, 2.317466974258423, 2.319546937942505, 2.3163468837738037, 2.319706916809082, 2.322587013244629, 2.327867031097412, 2.3222579956054688, 2.318747043609619, 2.3233869075775146, 2.318587064743042, 2.332026958465576, 2.3214659690856934], "compile_time": 527.8685293160379, "verification_time": 0, "benchmark_time": 75.56926505640149, "GFLOP/s": 3250.3395948018747, "strategy_time": 0, "framework_time": 1.4809775166213512, "timestamp": "2023-12-21 10:45:07.737883+00:00"},
+"16,1,1,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.7896979227662086, "times": [4.0106048583984375, 3.7926828861236572, 3.7870841026306152, 3.7789230346679688, 3.7786030769348145, 3.7798829078674316, 3.7858030796051025, 3.7779629230499268, 3.7774829864501953, 3.7795629501342773, 3.784363031387329, 3.777003049850464, 3.780042886734009, 3.7850029468536377, 3.7829229831695557, 3.784044027328491, 3.7838690280914307, 3.7859630584716797, 3.7816429138183594, 3.7806830406188965, 3.7794039249420166, 3.781162977218628, 3.7870841026306152, 3.7832438945770264, 3.78324294090271, 3.786763906478882, 3.7811639308929443, 3.7819631099700928, 3.782923936843872, 3.785964012145996, 3.781162977218628, 3.7821240425109863], "compile_time": 454.8558471724391, "verification_time": 0, "benchmark_time": 122.47234024107456, "GFLOP/s": 1992.176514820797, "strategy_time": 0, "framework_time": 1.3253865763545036, "timestamp": "2023-12-21 10:45:08.316553+00:00"},
+"16,1,1,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.8466677367687225, "times": [3.8757240772247314, 3.8467650413513184, 3.8525240421295166, 3.8445239067077637, 3.846445083618164, 3.8472440242767334, 3.843724012374878, 3.8390839099884033, 3.8470840454101562, 3.846924066543579, 3.848043918609619, 3.842284917831421, 3.8483641147613525, 3.844844102859497, 3.8504440784454346, 3.845963954925537, 3.8476779460906982, 3.844844102859497, 3.8424439430236816, 3.8512439727783203, 3.841644048690796, 3.842603921890259, 3.841804027557373, 3.8451640605926514, 3.843883991241455, 3.8429250717163086, 3.8403639793395996, 3.848844051361084, 3.843883991241455, 3.8501250743865967, 3.8483641147613525, 3.8475639820098877], "compile_time": 456.09104027971625, "verification_time": 0, "benchmark_time": 124.17517928406596, "GFLOP/s": 1962.672036327717, "strategy_time": 0, "framework_time": 1.4535635709762573, "timestamp": "2023-12-21 10:45:08.898288+00:00"},
+"16,1,1,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.3313023447990417, "times": [2.355705976486206, 2.328986883163452, 2.3230669498443604, 2.324666976928711, 2.3245060443878174, 2.3267459869384766, 2.322906970977783, 2.3237059116363525, 2.3243460655212402, 2.321626901626587, 2.519068956375122, 2.3273870944976807, 2.3225860595703125, 2.3264269828796387, 2.3272271156311035, 2.325627088546753, 2.320827007293701, 2.3243470191955566, 2.3225860595703125, 2.3251469135284424, 2.3259470462799072, 2.3219470977783203, 2.322746992111206, 2.3142659664154053, 2.3267459869384766, 2.3230669498443604, 2.3230860233306885, 2.3213069438934326, 2.324186086654663, 2.3281869888305664, 2.3241870403289795, 2.3285069465637207], "compile_time": 480.0516339018941, "verification_time": 0, "benchmark_time": 76.23218884691596, "GFLOP/s": 3238.4247443678473, "strategy_time": 0, "framework_time": 1.2866612523794174, "timestamp": "2023-12-21 10:45:09.455874+00:00"},
+"16,1,1,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.7741837427020073, "times": [3.8050029277801514, 3.777163028717041, 3.7714040279388428, 3.7738029956817627, 3.7787630558013916, 3.7701239585876465, 3.769002914428711, 3.777323007583618, 3.7683639526367188, 3.7693240642547607, 3.773163080215454, 3.773803949356079, 3.7714040279388428, 3.7715630531311035, 3.777323007583618, 3.7704429626464844, 3.76997709274292, 3.7706029415130615, 3.776524066925049, 3.7746028900146484, 3.7741239070892334, 3.771883964538574, 3.7754030227661133, 3.7725229263305664, 3.7725229263305664, 3.77012300491333, 3.7714030742645264, 3.7725229263305664, 3.774282932281494, 3.773163080215454, 3.781964063644409, 3.774282932281494], "compile_time": 448.8627868704498, "verification_time": 0, "benchmark_time": 122.15729895979166, "GFLOP/s": 2000.3655663555471, "strategy_time": 0, "framework_time": 1.4242101460695267, "timestamp": "2023-12-21 10:45:10.028335+00:00"},
+"16,1,1,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.809337370097637, "times": [3.8326830863952637, 3.8179640769958496, 3.803083896636963, 3.801323890686035, 3.8029229640960693, 3.8024439811706543, 3.8059639930725098, 3.8018031120300293, 3.8014841079711914, 3.7994039058685303, 3.800363063812256, 3.8035640716552734, 3.8013229370117188, 3.8021240234375, 3.8022830486297607, 3.801323890686035, 3.8025619983673096, 3.8035640716552734, 3.8022830486297607, 3.8026039600372314, 3.973484992980957, 3.8050038814544678, 3.8048439025878906, 3.8083629608154297, 3.8024439811706543, 3.8048439025878906, 3.801003932952881, 3.802284002304077, 3.802443027496338, 3.8019630908966064, 3.8006839752197266, 3.800363063812256], "compile_time": 449.43161914125085, "verification_time": 0, "benchmark_time": 123.79821809008718, "GFLOP/s": 1981.905635154203, "strategy_time": 0, "framework_time": 1.4880327507853508, "timestamp": "2023-12-21 10:45:10.603068+00:00"},
+"16,1,2,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.78267040848732, "times": [11.789734840393066, 11.770054817199707, 11.774054527282715, 11.785575866699219, 11.780455589294434, 11.777687072753906, 11.784934997558594, 11.786215782165527, 11.78381633758545, 11.787015914916992, 11.782535552978516, 11.779899597167969, 11.779014587402344, 11.788294792175293, 11.785896301269531, 11.788616180419922, 11.779974937438965, 11.784403800964355, 11.783975601196289, 11.77885627746582, 11.777735710144043, 11.77885627746582, 11.793416023254395, 11.783649444580078, 11.784614562988281, 11.784775733947754, 11.781736373901367, 11.785735130310059, 11.78381633758545, 11.775032997131348, 11.783815383911133, 11.781255722045898], "compile_time": 972.4751622416079, "verification_time": 0, "benchmark_time": 378.2742409966886, "GFLOP/s": 640.7500963925587, "strategy_time": 0, "framework_time": 1.2645605020225048, "timestamp": "2023-12-21 10:45:11.955098+00:00"},
+"16,1,2,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.86026132106781, "times": [11.878055572509766, 11.856136322021484, 11.85373592376709, 11.854537010192871, 11.854056358337402, 11.855210304260254, 11.849897384643555, 11.854696273803711, 11.85789680480957, 11.855816841125488, 11.851656913757324, 11.85958480834961, 11.855016708374023, 11.851177215576172, 11.851016998291016, 11.850056648254395, 11.859335899353027, 11.856810569763184, 11.846857070922852, 11.853896141052246, 11.854537010192871, 11.858535766601562, 11.85341739654541, 11.852826118469238, 11.853416442871094, 11.852456092834473, 11.852617263793945, 11.856295585632324, 11.85037612915039, 11.856719970703125, 12.02333927154541, 11.858377456665039], "compile_time": 421.84273805469275, "verification_time": 0, "benchmark_time": 381.0129868797958, "GFLOP/s": 636.5582507519553, "strategy_time": 0, "framework_time": 1.3672779314219952, "timestamp": "2023-12-21 10:45:12.759336+00:00"},
+"16,1,2,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.854690343141556, "times": [11.881095886230469, 11.854536056518555, 11.856136322021484, 11.855016708374023, 11.852136611938477, 11.85372257232666, 11.853256225585938, 11.861096382141113, 11.852457046508789, 11.854536056518555, 11.851335525512695, 11.85393238067627, 11.850696563720703, 11.852935791015625, 11.854216575622559, 11.854696273803711, 11.853096961975098, 11.851645469665527, 11.849257469177246, 11.853256225585938, 11.852936744689941, 11.849896430969238, 11.851977348327637, 11.855411529541016, 11.858375549316406, 11.848775863647461, 11.854215621948242, 11.85373592376709, 11.854697227478027, 11.858575820922852, 11.855497360229492, 11.85693645477295], "compile_time": 423.715575132519, "verification_time": 0, "benchmark_time": 380.9834588319063, "GFLOP/s": 636.8573941172449, "strategy_time": 0, "framework_time": 1.350486185401678, "timestamp": "2023-12-21 10:45:13.565400+00:00"},
+"16,1,2,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.540795400738716, "times": [6.572714805603027, 6.537196159362793, 6.538475036621094, 6.535274982452393, 6.532875061035156, 6.541035175323486, 6.535915851593018, 6.537994861602783, 6.535594940185547, 6.539331912994385, 6.537515163421631, 6.542634963989258, 6.541035175323486, 6.539754867553711, 6.539595127105713, 6.541675090789795, 6.539595127105713, 6.541194915771484, 6.541194915771484, 6.537703037261963, 6.54615592956543, 6.541676044464111, 6.541675090789795, 6.539435863494873, 6.540555000305176, 6.540555000305176, 6.539115905761719, 6.541035175323486, 6.5402350425720215, 6.539996147155762, 6.54247522354126, 6.5442352294921875], "compile_time": 477.15699579566717, "verification_time": 0, "benchmark_time": 211.28627005964518, "GFLOP/s": 1154.2552147629222, "strategy_time": 0, "framework_time": 1.209133304655552, "timestamp": "2023-12-21 10:45:14.255067+00:00"},
+"16,1,2,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.838640570640564, "times": [11.855976104736328, 11.837096214294434, 11.836775779724121, 11.830536842346191, 11.828935623168945, 11.828145980834961, 11.83741569519043, 12.0260591506958, 11.836617469787598, 11.838055610656738, 11.83901596069336, 11.830047607421875, 11.827495574951172, 11.829575538635254, 11.833577156066895, 11.832136154174805, 11.829095840454102, 11.834219932556152, 11.82973575592041, 11.826696395874023, 11.83133602142334, 11.830857276916504, 11.833255767822266, 11.828313827514648, 11.8324556350708, 11.827336311340332, 11.829895973205566, 11.8311767578125, 11.830857276916504, 11.831609725952148, 11.83133602142334, 11.830857276916504], "compile_time": 416.9838950037956, "verification_time": 0, "benchmark_time": 380.1692328415811, "GFLOP/s": 637.7207885441782, "strategy_time": 0, "framework_time": 1.3690423220396042, "timestamp": "2023-12-21 10:45:15.053604+00:00"},
+"16,1,2,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.832034021615982, "times": [11.85805606842041, 11.830535888671875, 11.833576202392578, 11.828777313232422, 11.827496528625488, 11.828967094421387, 11.83293628692627, 11.830856323242188, 11.831016540527344, 11.82845687866211, 11.830376625061035, 11.831186294555664, 11.830696105957031, 11.830697059631348, 11.831496238708496, 11.829416275024414, 11.829895973205566, 11.828810691833496, 11.828455924987793, 11.827336311340332, 11.827337265014648, 11.831815719604492, 11.827816009521484, 11.833576202392578, 11.830535888671875, 11.831016540527344, 11.831815719604492, 11.835975646972656, 11.841256141662598, 11.834229469299316, 11.836615562438965, 11.83405590057373], "compile_time": 419.4878148846328, "verification_time": 0, "benchmark_time": 380.10577019304037, "GFLOP/s": 638.0768671056339, "strategy_time": 0, "framework_time": 1.379622146487236, "timestamp": "2023-12-21 10:45:15.854593+00:00"},
+"16,1,2,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 4.1925869435071945, "times": [4.214767932891846, 4.18452787399292, 4.181969165802002, 4.180528163909912, 4.189807891845703, 4.18644905090332, 4.18452787399292, 4.18452787399292, 4.184688091278076, 4.184207916259766, 4.18228816986084, 4.182608127593994, 4.185967922210693, 4.186929225921631, 4.182981967926025, 4.182767868041992, 4.369170188903809, 4.201808929443359, 4.190769195556641, 4.190767765045166, 4.184207916259766, 4.185967922210693, 4.184368133544922, 4.1891679763793945, 4.1875691413879395, 4.188208103179932, 4.187889099121094, 4.177649021148682, 4.191567897796631, 4.18874979019165, 4.188528060913086, 4.1768479347229], "compile_time": 995.5906178802252, "verification_time": 0, "benchmark_time": 135.3556257672608, "GFLOP/s": 1800.737182491072, "strategy_time": 0, "framework_time": 1.451974269002676, "timestamp": "2023-12-21 10:45:16.987007+00:00"},
+"16,1,2,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.399570733308792, "times": [6.436392784118652, 6.400874137878418, 6.400554180145264, 6.40135383605957, 6.399593830108643, 6.402153968811035, 6.397034168243408, 6.401194095611572, 6.399433135986328, 6.397296905517578, 6.398313999176025, 6.395914077758789, 6.394952774047852, 6.397193908691406, 6.395913124084473, 6.402313232421875, 6.393834114074707, 6.397833824157715, 6.396873950958252, 6.397027969360352, 6.399592876434326, 6.39863395690918, 6.399272918701172, 6.398313999176025, 6.399592876434326, 6.3973541259765625, 6.396714210510254, 6.396714210510254, 6.399913787841797, 6.3973212242126465, 6.400073051452637, 6.396714210510254], "compile_time": 565.660024061799, "verification_time": 0, "benchmark_time": 206.5479219891131, "GFLOP/s": 1179.7271277438522, "strategy_time": 0, "framework_time": 1.3665980659425259, "timestamp": "2023-12-21 10:45:17.760596+00:00"},
+"16,1,2,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.405186951160431, "times": [6.433193206787109, 6.407273769378662, 6.40151309967041, 6.397833824157715, 6.398152828216553, 6.396073818206787, 6.395113945007324, 6.399913787841797, 6.394954204559326, 6.397512912750244, 6.400234222412109, 6.410953998565674, 6.395593166351318, 6.397193908691406, 6.395432949066162, 6.396234035491943, 6.402793884277344, 6.395273208618164, 6.3975138664245605, 6.397902011871338, 6.396393775939941, 6.401834011077881, 6.39719295501709, 6.3975138664245605, 6.400713920593262, 6.573835849761963, 6.401514053344727, 6.396714210510254, 6.396072864532471, 6.401709079742432, 6.396234035491943, 6.395593166351318], "compile_time": 565.6307879835367, "verification_time": 0, "benchmark_time": 206.80135395377874, "GFLOP/s": 1178.6927153831487, "strategy_time": 0, "framework_time": 1.4368831180036068, "timestamp": "2023-12-21 10:45:18.534480+00:00"},
+"16,1,2,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.569371871650219, "times": [3.5987610816955566, 3.5675621032714844, 3.57892107963562, 3.5656421184539795, 3.571721076965332, 3.5723609924316406, 3.5722010135650635, 3.5642011165618896, 3.5650010108947754, 3.568202018737793, 3.5682010650634766, 3.564521074295044, 3.5632410049438477, 3.5650010108947754, 3.5651609897613525, 3.566761016845703, 3.567720890045166, 3.5675830841064453, 3.5672409534454346, 3.5733211040496826, 3.567720890045166, 3.5648410320281982, 3.571561098098755, 3.5674009323120117, 3.567081928253174, 3.573641061782837, 3.5701210498809814, 3.5683610439300537, 3.5746009349823, 3.566601037979126, 3.5666019916534424, 3.5680410861968994], "compile_time": 607.2850460186601, "verification_time": 0, "benchmark_time": 115.39663374423981, "GFLOP/s": 2115.14727842284, "strategy_time": 0, "framework_time": 1.2952890247106552, "timestamp": "2023-12-21 10:45:19.258472+00:00"},
+"16,1,2,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.388249441981316, "times": [6.41735315322876, 6.388554096221924, 6.395594120025635, 6.384714126586914, 6.388393878936768, 6.3856730461120605, 6.3952741622924805, 6.386474132537842, 6.386953830718994, 6.389636039733887, 6.387434005737305, 6.385834217071533, 6.387592792510986, 6.389033794403076, 6.390153884887695, 6.383432865142822, 6.390313148498535, 6.387433052062988, 6.385034084320068, 6.387250900268555, 6.381194114685059, 6.381673812866211, 6.383273124694824, 6.393513202667236, 6.384873867034912, 6.387434005737305, 6.3906331062316895, 6.381834030151367, 6.389674186706543, 6.386877059936523, 6.3840742111206055, 6.386794090270996], "compile_time": 555.866985116154, "verification_time": 0, "benchmark_time": 205.74615895748138, "GFLOP/s": 1181.8178467462044, "strategy_time": 0, "framework_time": 1.3479399494826794, "timestamp": "2023-12-21 10:45:20.021447+00:00"},
+"16,1,2,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.391178667545319, "times": [6.411592960357666, 6.3842339515686035, 6.58711576461792, 6.384552955627441, 6.393672943115234, 6.383274078369141, 6.386794090270996, 6.385354042053223, 6.382472991943359, 6.379292964935303, 6.380713939666748, 6.384072780609131, 6.381514072418213, 6.383433818817139, 6.3842339515686035, 6.381514072418213, 6.383594036102295, 6.379912853240967, 6.383752822875977, 6.379921913146973, 6.381673812866211, 6.3856730461120605, 6.383112907409668, 6.3821539878845215, 6.38279390335083, 6.385354042053223, 6.387113094329834, 6.385832786560059, 6.388073921203613, 6.383409023284912, 6.387753009796143, 6.383752822875977], "compile_time": 558.9388948865235, "verification_time": 0, "benchmark_time": 205.9198459610343, "GFLOP/s": 1181.276192189391, "strategy_time": 0, "framework_time": 1.3559362851083279, "timestamp": "2023-12-21 10:45:20.787679+00:00"},
+"16,1,2,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 85.79105234146118, "times": [85.76734161376953, 85.88050842285156, 85.80484008789062, 85.78658294677734, 85.79613494873047, 85.74163055419922, 85.80030822753906, 85.83904266357422, 85.78404998779297, 85.80035400390625, 85.78643035888672, 85.73220825195312, 85.75702667236328, 85.76859283447266, 85.81224060058594, 85.79326629638672, 85.75676727294922, 85.70787048339844, 85.8935317993164, 85.80242919921875, 85.7370376586914, 85.80659484863281, 85.86688232421875, 85.73503875732422, 85.87739562988281, 85.86105346679688, 85.81874084472656, 85.73462677001953, 85.81014251708984, 85.77690124511719, 85.71578979492188, 85.76231384277344], "compile_time": 1682.2135192342103, "verification_time": 0, "benchmark_time": 2746.9814899377525, "GFLOP/s": 88.00156885768087, "strategy_time": 0, "framework_time": 1.2713335454463959, "timestamp": "2023-12-21 10:45:25.218160+00:00"},
+"16,1,2,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 35.21394348144531, "times": [35.088565826416016, 35.255008697509766, 35.18008804321289, 35.201751708984375, 35.20760726928711, 35.205894470214844, 35.23352813720703, 35.25932312011719, 35.22568893432617, 35.20568084716797, 35.2669677734375, 35.4788818359375, 35.25608825683594, 35.01616668701172, 35.28104782104492, 35.223018646240234, 35.32680892944336, 35.18528747558594, 35.1908073425293, 35.20247268676758, 35.223289489746094, 35.12819290161133, 35.04552459716797, 35.31169509887695, 35.29800796508789, 35.33539962768555, 35.145687103271484, 35.12677764892578, 35.26824951171875, 35.167293548583984, 35.155128479003906, 35.15026092529297], "compile_time": 776.8486458808184, "verification_time": 0, "benchmark_time": 1128.562637604773, "GFLOP/s": 214.39652744311527, "strategy_time": 0, "framework_time": 1.6130045987665653, "timestamp": "2023-12-21 10:45:27.125200+00:00"},
+"16,1,2,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 35.243252754211426, "times": [35.425689697265625, 35.248958587646484, 35.21944808959961, 35.30366897583008, 35.269046783447266, 35.15663528442383, 35.35144805908203, 35.138004302978516, 35.312889099121094, 35.251670837402344, 35.204246520996094, 35.078834533691406, 35.30936813354492, 35.232398986816406, 35.165367126464844, 35.19478225708008, 35.27880859375, 35.359130859375, 35.16520690917969, 35.1908073425293, 35.41000747680664, 35.2751350402832, 35.24408721923828, 35.21403121948242, 35.26744842529297, 35.28125762939453, 35.282169342041016, 35.16228103637695, 35.088722229003906, 35.2137451171875, 35.20216751098633, 35.286624908447266], "compile_time": 776.6702696681023, "verification_time": 0, "benchmark_time": 1129.4276230037212, "GFLOP/s": 214.21822930625595, "strategy_time": 0, "framework_time": 1.55743770301342, "timestamp": "2023-12-21 10:45:29.032871+00:00"},
+"16,1,2,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 82.8276116847992, "times": [82.89037322998047, 82.84140014648438, 82.83293151855469, 82.85240173339844, 82.79234313964844, 82.84051513671875, 82.85005950927734, 82.82086181640625, 82.7953109741211, 82.73762512207031, 82.8677978515625, 82.75569152832031, 82.81598663330078, 82.76747131347656, 82.84950256347656, 82.86996459960938, 82.8657455444336, 82.84950256347656, 82.77571105957031, 82.8716049194336, 82.98302459716797, 82.83992767333984, 82.76799774169922, 82.83246612548828, 82.81851196289062, 82.79185485839844, 82.63047790527344, 82.88324737548828, 82.76366424560547, 82.83245086669922, 82.96868896484375, 82.82846069335938], "compile_time": 1818.9812498167157, "verification_time": 0, "benchmark_time": 2652.1127107553184, "GFLOP/s": 91.15012550078822, "strategy_time": 0, "framework_time": 1.51141919195652, "timestamp": "2023-12-21 10:45:33.505492+00:00"},
+"16,1,2,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 35.27253234386444, "times": [35.41752624511719, 35.196163177490234, 35.28904724121094, 35.255577087402344, 35.25960922241211, 35.2326545715332, 35.284889221191406, 35.26234436035156, 35.049686431884766, 35.35795211791992, 35.143768310546875, 35.26472854614258, 35.16648864746094, 35.32205581665039, 35.135929107666016, 35.315555572509766, 35.37864685058594, 35.20530700683594, 35.272247314453125, 35.37441635131836, 35.15128707885742, 35.34872055053711, 35.35880661010742, 35.362308502197266, 35.18360900878906, 35.40892028808594, 35.286808013916016, 35.35618209838867, 35.22616958618164, 35.3072624206543, 35.23576736450195, 35.31060028076172], "compile_time": 776.477016042918, "verification_time": 0, "benchmark_time": 1130.3582559339702, "GFLOP/s": 214.0404076009943, "strategy_time": 0, "framework_time": 1.4628232456743717, "timestamp": "2023-12-21 10:45:35.413806+00:00"},
+"16,1,2,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 35.24172234535217, "times": [35.403446197509766, 35.167076110839844, 35.2298469543457, 35.32351303100586, 35.289527893066406, 35.119293212890625, 35.27784729003906, 35.25857162475586, 35.20200729370117, 35.21830368041992, 35.23688888549805, 35.16423416137695, 35.41960906982422, 35.35996627807617, 35.162967681884766, 35.28557586669922, 35.179927825927734, 35.12015151977539, 35.12584686279297, 35.24068832397461, 35.227447509765625, 35.20941162109375, 35.088409423828125, 35.30795669555664, 35.24824905395508, 35.18889617919922, 35.3159294128418, 35.355167388916016, 35.18680953979492, 35.430824279785156, 35.15032958984375, 35.240394592285156], "compile_time": 777.7400831691921, "verification_time": 0, "benchmark_time": 1129.284786991775, "GFLOP/s": 214.22753195817322, "strategy_time": 0, "framework_time": 1.4483151026070118, "timestamp": "2023-12-21 10:45:37.322295+00:00"},
+"16,1,2,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.437730506062508, "times": [7.455766201019287, 7.426486015319824, 7.427445888519287, 7.42616605758667, 7.429366111755371, 7.437526226043701, 7.438325881958008, 7.437046051025391, 7.433862209320068, 7.432246208190918, 7.433045864105225, 7.4359259605407715, 7.438325881958008, 7.4359259605407715, 7.47240686416626, 7.439606189727783, 7.435445785522461, 7.440961837768555, 7.434805870056152, 7.437685966491699, 7.434326171875, 7.436406135559082, 7.43816614151001, 7.4380059242248535, 7.434966087341309, 7.436726093292236, 7.444296836853027, 7.4442458152771, 7.4380059242248535, 7.4338459968566895, 7.440246105194092, 7.439765930175781], "compile_time": 1023.8616028800607, "verification_time": 0, "benchmark_time": 239.43855380639434, "GFLOP/s": 1015.0606013280781, "strategy_time": 0, "framework_time": 1.472382340580225, "timestamp": "2023-12-21 10:45:38.587082+00:00"},
+"16,1,2,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.6794996857643127, "times": [3.712682008743286, 3.686763048171997, 3.6821229457855225, 3.6760430335998535, 3.680202007293701, 3.677643060684204, 3.6779630184173584, 3.680042028427124, 3.676522970199585, 3.677483081817627, 3.678762912750244, 3.6787619590759277, 3.6818020343780518, 3.679403066635132, 3.67732310295105, 3.677001953125, 3.6773900985717773, 3.67732310295105, 3.677643060684204, 3.6786019802093506, 3.6779630184173584, 3.679563045501709, 3.6774818897247314, 3.6784420013427734, 3.6771628856658936, 3.6771628856658936, 3.679081916809082, 3.677001953125, 3.678602933883667, 3.6758830547332764, 3.677161931991577, 3.677001953125], "compile_time": 888.5291409678757, "verification_time": 0, "benchmark_time": 119.5941842161119, "GFLOP/s": 2051.840697040786, "strategy_time": 0, "framework_time": 1.3755648396909237, "timestamp": "2023-12-21 10:45:39.596596+00:00"},
+"16,1,2,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.6866346672177315, "times": [3.7283620834350586, 3.6850030422210693, 3.681001901626587, 3.6792430877685547, 3.693643093109131, 3.6779630184173584, 3.878765106201172, 3.6808431148529053, 3.680042028427124, 3.6790831089019775, 3.6760430335998535, 3.677643060684204, 3.6766819953918457, 3.675723075866699, 3.683722972869873, 3.679403066635132, 3.67706298828125, 3.678122043609619, 3.67732310295105, 3.6779630184173584, 3.680202007293701, 3.6782829761505127, 3.6758830547332764, 3.677802085876465, 3.676841974258423, 3.676522970199585, 3.6760430335998535, 3.677962064743042, 3.6792430877685547, 3.6760430335998535, 3.67732310295105, 3.6765220165252686], "compile_time": 889.7682121023536, "verification_time": 0, "benchmark_time": 119.79815037921071, "GFLOP/s": 2047.869637622033, "strategy_time": 0, "framework_time": 1.3861535117030144, "timestamp": "2023-12-21 10:45:40.607563+00:00"},
+"16,1,2,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.2540850043296814, "times": [2.287385940551758, 2.2590670585632324, 2.2521860599517822, 2.2513859272003174, 2.249785900115967, 2.2523460388183594, 2.253145933151245, 2.254746913909912, 2.2505860328674316, 2.2544260025024414, 2.2547459602355957, 2.2517058849334717, 2.252825975418091, 2.2528269290924072, 2.25506591796875, 2.253786087036133, 2.2531468868255615, 2.252985954284668, 2.2542660236358643, 2.252985954284668, 2.2533059120178223, 2.253145933151245, 2.2502670288085938, 2.253786087036133, 2.2510669231414795, 2.249785900115967, 2.2534658908843994, 2.249908924102783, 2.252825975418091, 2.253786087036133, 2.2526659965515137, 2.2573060989379883], "compile_time": 985.8970218338072, "verification_time": 0, "benchmark_time": 73.22301901876926, "GFLOP/s": 3349.36224033181, "strategy_time": 0, "framework_time": 1.3628602027893066, "timestamp": "2023-12-21 10:45:41.668061+00:00"},
+"16,1,2,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.672501266002655, "times": [3.7016420364379883, 3.6742820739746094, 3.6698029041290283, 3.6666030883789062, 3.669002056121826, 3.6650021076202393, 3.6622819900512695, 3.6645219326019287, 3.6635630130767822, 3.661642074584961, 3.6645219326019287, 3.666282892227173, 3.664522886276245, 3.662761926651001, 3.666282892227173, 3.665482997894287, 3.858083963394165, 3.667881965637207, 3.665961980819702, 3.664362907409668, 3.6677229404449463, 3.670283079147339, 3.6640429496765137, 3.6650021076202393, 3.662921905517578, 3.6648430824279785, 3.662921905517578, 3.6622819900512695, 3.664202928543091, 3.6627631187438965, 3.6643619537353516, 3.664202928543091], "compile_time": 883.4149949252605, "verification_time": 0, "benchmark_time": 119.58252172917128, "GFLOP/s": 2055.750741297237, "strategy_time": 0, "framework_time": 1.3849930837750435, "timestamp": "2023-12-21 10:45:42.672459+00:00"},
+"16,1,2,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.666209951043129, "times": [3.704521894454956, 3.6712429523468018, 3.669322967529297, 3.665802001953125, 3.6640429496765137, 3.6646831035614014, 3.66388201713562, 3.667881965637207, 3.664202928543091, 3.664202928543091, 3.664681911468506, 3.662282943725586, 3.662442922592163, 3.6619629859924316, 3.663243055343628, 3.6645219326019287, 3.6644411087036133, 3.662282943725586, 3.6645219326019287, 3.662761926651001, 3.673801898956299, 3.663722038269043, 3.6627631187438965, 3.663403034210205, 3.6682019233703613, 3.6651620864868164, 3.665163040161133, 3.6630818843841553, 3.667562961578369, 3.6651620864868164, 3.6632421016693115, 3.664522886276245], "compile_time": 885.1803950965405, "verification_time": 0, "benchmark_time": 119.39964815974236, "GFLOP/s": 2059.2784649040373, "strategy_time": 0, "framework_time": 1.279427669942379, "timestamp": "2023-12-21 10:45:43.678334+00:00"},
+"16,1,3,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 98.68609976768494, "times": [98.73167419433594, 98.6534652709961, 98.7041244506836, 98.61058044433594, 98.635986328125, 98.7404556274414, 98.75115203857422, 98.59880828857422, 98.70358276367188, 98.76373291015625, 98.65613555908203, 98.70391082763672, 98.6671371459961, 98.59037017822266, 98.63126373291016, 98.64437866210938, 98.78759765625, 98.71809387207031, 98.64954376220703, 98.64059448242188, 98.65007019042969, 98.5600814819336, 98.72560119628906, 98.73636627197266, 98.61102294921875, 98.81018829345703, 98.87379455566406, 98.76954650878906, 98.65203857421875, 98.66452026367188, 98.64254760742188, 98.67682647705078], "compile_time": 2369.4319841451943, "verification_time": 0, "benchmark_time": 3159.4343902543187, "GFLOP/s": 76.50264036954258, "strategy_time": 0, "framework_time": 1.328793354332447, "timestamp": "2023-12-21 10:45:49.208545+00:00"},
+"16,1,3,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.5080748796463, "times": [34.58456039428711, 34.473209381103516, 34.53416061401367, 34.510982513427734, 34.517520904541016, 34.53752136230469, 34.50360107421875, 34.51926803588867, 34.524879455566406, 34.53410720825195, 34.52648162841797, 34.45603561401367, 34.50664138793945, 34.498252868652344, 34.48984146118164, 34.563140869140625, 34.51736068725586, 34.50239181518555, 34.51927947998047, 34.48127365112305, 34.473838806152344, 34.47782897949219, 34.466800689697266, 34.45555877685547, 34.585838317871094, 34.42529296875, 34.54008102416992, 34.53694534301758, 34.52360153198242, 34.46164321899414, 34.5125617980957, 34.497894287109375], "compile_time": 545.2979612164199, "verification_time": 0, "benchmark_time": 1105.829011183232, "GFLOP/s": 218.78204525553014, "strategy_time": 0, "framework_time": 1.4575025998055935, "timestamp": "2023-12-21 10:45:50.861145+00:00"},
+"16,1,3,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 38.03405463695526, "times": [38.106361389160156, 38.13273239135742, 37.998680114746094, 38.050376892089844, 38.010520935058594, 38.00154113769531, 38.017879486083984, 38.04538345336914, 38.03356170654297, 38.00864791870117, 38.03900146484375, 38.073455810546875, 37.99932098388672, 38.03961944580078, 38.03036117553711, 38.05839920043945, 38.02587890625, 38.04607009887695, 38.05788040161133, 38.109981536865234, 38.03868103027344, 37.990413665771484, 38.01227951049805, 38.00949478149414, 38.005401611328125, 37.96745300292969, 37.97867965698242, 37.99745559692383, 38.04636001586914, 38.07505416870117, 38.04859924316406, 38.03422164916992], "compile_time": 547.7033513598144, "verification_time": 0, "benchmark_time": 1218.6060608364642, "GFLOP/s": 198.49966752333557, "strategy_time": 0, "framework_time": 1.4703567139804363, "timestamp": "2023-12-21 10:45:52.628940+00:00"},
+"16,1,3,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 97.19803404808044, "times": [97.33732604980469, 97.24298095703125, 97.2463607788086, 97.3448486328125, 97.23310852050781, 97.19416809082031, 97.11902618408203, 97.13424682617188, 97.21748352050781, 97.18643188476562, 97.15167236328125, 97.1552505493164, 97.24845123291016, 97.15782928466797, 97.1886978149414, 97.2108383178711, 97.16265106201172, 97.14901733398438, 97.14378356933594, 97.16767883300781, 97.14498901367188, 97.25428771972656, 97.161376953125, 97.18030548095703, 97.27118682861328, 97.26949310302734, 97.2184829711914, 97.15343475341797, 97.22911071777344, 97.15243530273438, 97.072509765625, 97.23762512207031], "compile_time": 4582.197329029441, "verification_time": 0, "benchmark_time": 3111.8997908197343, "GFLOP/s": 77.6738673157258, "strategy_time": 0, "framework_time": 1.4969599433243275, "timestamp": "2023-12-21 10:46:00.324549+00:00"},
+"16,1,3,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.47822093963623, "times": [34.5872802734375, 34.46943664550781, 34.49720001220703, 34.48906326293945, 34.44855880737305, 34.488521575927734, 34.4410400390625, 34.47473907470703, 34.44776153564453, 34.453895568847656, 34.48231887817383, 34.4259147644043, 34.46311950683594, 34.43720245361328, 34.49879837036133, 34.503822326660156, 34.54888153076172, 34.451438903808594, 34.444881439208984, 34.42329788208008, 34.43592071533203, 34.39781951904297, 34.45991897583008, 34.50456619262695, 34.45783996582031, 34.527034759521484, 34.54056167602539, 34.453834533691406, 34.49095916748047, 34.508880615234375, 34.55064010620117, 34.497920989990234], "compile_time": 544.6916869841516, "verification_time": 0, "benchmark_time": 1104.7294898889959, "GFLOP/s": 218.97148385985295, "strategy_time": 0, "framework_time": 1.5526977367699146, "timestamp": "2023-12-21 10:46:01.975540+00:00"},
+"16,1,3,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 37.99961173534393, "times": [38.128604888916016, 38.04466247558594, 38.011478424072266, 37.98209762573242, 37.9841194152832, 37.988990783691406, 38.01676559448242, 37.97002410888672, 37.988121032714844, 38.008750915527344, 37.98971939086914, 37.929107666015625, 38.005882263183594, 38.176025390625, 37.984439849853516, 38.07292175292969, 37.98699951171875, 38.02482986450195, 38.00107955932617, 38.00484085083008, 38.00140380859375, 37.950958251953125, 37.952598571777344, 37.944358825683594, 37.97211837768555, 37.961265563964844, 37.97515869140625, 38.01637649536133, 37.96268081665039, 38.043296813964844, 37.934200286865234, 37.973697662353516], "compile_time": 546.9733569771051, "verification_time": 0, "benchmark_time": 1217.6133370958269, "GFLOP/s": 198.679587901628, "strategy_time": 0, "framework_time": 1.4027082361280918, "timestamp": "2023-12-21 10:46:03.741545+00:00"},
+"16,1,3,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 85.62335181236267, "times": [85.66253662109375, 85.63343811035156, 85.60537719726562, 85.68148040771484, 85.62982177734375, 85.61202239990234, 85.61944580078125, 85.66622161865234, 85.6004867553711, 85.65185546875, 85.59765625, 85.5984115600586, 85.6182861328125, 85.603271484375, 85.61274719238281, 85.63694763183594, 85.64884948730469, 85.6467514038086, 85.60003662109375, 85.64610290527344, 85.6430892944336, 85.60179901123047, 85.65428924560547, 85.58256530761719, 85.56742095947266, 85.5859146118164, 85.63264465332031, 85.60225677490234, 85.63096618652344, 85.6312026977539, 85.63207244873047, 85.61128997802734], "compile_time": 1634.183089248836, "verification_time": 0, "benchmark_time": 2741.732602007687, "GFLOP/s": 88.1739273246943, "strategy_time": 0, "framework_time": 1.4202524907886982, "timestamp": "2023-12-21 10:46:08.118898+00:00"},
+"16,1,3,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.38883113861084, "times": [43.65410614013672, 43.301998138427734, 43.38850402832031, 43.24988555908203, 43.362422943115234, 43.33620834350586, 43.31138229370117, 43.37091064453125, 43.411224365234375, 43.354225158691406, 43.38386535644531, 43.37411117553711, 43.38274383544922, 43.33819580078125, 43.361785888671875, 43.41218948364258, 43.47122573852539, 43.40782165527344, 43.37410354614258, 43.398197174072266, 43.315223693847656, 43.35645294189453, 43.38866424560547, 43.58438491821289, 43.34978485107422, 43.36153030395508, 43.440345764160156, 43.43008804321289, 43.43490219116211, 43.393497467041016, 43.33602523803711, 43.40658950805664], "compile_time": 866.5564809925854, "verification_time": 0, "benchmark_time": 1389.9862617254257, "GFLOP/s": 174.00208767738923, "strategy_time": 0, "framework_time": 1.467953436076641, "timestamp": "2023-12-21 10:46:10.376924+00:00"},
+"16,1,3,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 46.571053862571716, "times": [46.65670394897461, 46.56511306762695, 46.56630325317383, 46.576576232910156, 46.653343200683594, 46.56465530395508, 46.613502502441406, 46.553062438964844, 46.59734344482422, 46.55527877807617, 46.52790069580078, 46.560760498046875, 46.565025329589844, 46.6407356262207, 46.55750274658203, 46.54627990722656, 46.5491828918457, 46.4996337890625, 46.55046463012695, 46.55791473388672, 46.60182571411133, 46.57573318481445, 46.61174392700195, 46.546630859375, 46.55366516113281, 46.57267761230469, 46.571102142333984, 46.58340835571289, 46.53525924682617, 46.54475784301758, 46.552703857421875, 46.566932678222656], "compile_time": 866.0695780999959, "verification_time": 0, "benchmark_time": 1491.8922651559114, "GFLOP/s": 162.11244053610713, "strategy_time": 0, "framework_time": 1.3769157230854034, "timestamp": "2023-12-21 10:46:12.736278+00:00"},
+"16,1,3,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 83.4284176826477, "times": [83.44683837890625, 83.48809051513672, 83.53446960449219, 83.40467071533203, 83.43816375732422, 83.41082763671875, 83.44830322265625, 83.42931365966797, 83.43292999267578, 83.38811492919922, 83.44684600830078, 83.3829116821289, 83.43620300292969, 83.42801666259766, 83.4343032836914, 83.42158508300781, 83.42296600341797, 83.43270111083984, 83.38452911376953, 83.44477844238281, 83.39341735839844, 83.48499298095703, 83.3876953125, 83.4293441772461, 83.38341522216797, 83.42852783203125, 83.38228607177734, 83.42818450927734, 83.43775177001953, 83.47644805908203, 83.4535903930664, 83.36714935302734], "compile_time": 1740.9245893359184, "verification_time": 0, "benchmark_time": 2671.3524381630123, "GFLOP/s": 90.49371197136192, "strategy_time": 0, "framework_time": 1.3739103451371193, "timestamp": "2023-12-21 10:46:17.149945+00:00"},
+"16,1,3,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.33765983581543, "times": [43.603065490722656, 43.36118698120117, 43.204185485839844, 43.300575256347656, 43.32834243774414, 43.41220474243164, 43.35346221923828, 43.317054748535156, 43.23906326293945, 43.43549346923828, 43.35490417480469, 43.24216842651367, 43.3686637878418, 43.362281799316406, 43.41602325439453, 43.318328857421875, 43.27938461303711, 43.30841064453125, 43.3150634765625, 43.361141204833984, 43.29042434692383, 43.38674545288086, 43.26514434814453, 43.31755065917969, 43.37986373901367, 43.35170364379883, 43.35602569580078, 43.386287689208984, 43.3675422668457, 43.201168060302734, 43.32962417602539, 43.292030334472656], "compile_time": 865.8115491271019, "verification_time": 0, "benchmark_time": 1388.237103819847, "GFLOP/s": 174.20754209161709, "strategy_time": 0, "framework_time": 1.4747348614037037, "timestamp": "2023-12-21 10:46:19.405485+00:00"},
+"16,1,3,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 47.38079476356506, "times": [47.49207305908203, 47.40945816040039, 47.370792388916016, 47.350181579589844, 47.44951248168945, 47.380245208740234, 47.334312438964844, 47.35054397583008, 47.37431335449219, 47.33415222167969, 47.312713623046875, 47.37569046020508, 47.43367385864258, 47.37393569946289, 47.395912170410156, 47.38705825805664, 47.38023376464844, 47.34352111816406, 47.41175079345703, 47.35009765625, 47.387271881103516, 47.4139518737793, 47.374473571777344, 47.325191497802734, 47.37751388549805, 47.410396575927734, 47.40983200073242, 47.42206573486328, 47.34231185913086, 47.42735290527344, 47.37111282348633, 47.313785552978516], "compile_time": 866.3448919542134, "verification_time": 0, "benchmark_time": 1517.7267319522798, "GFLOP/s": 159.34192825751444, "strategy_time": 0, "framework_time": 1.514964271336794, "timestamp": "2023-12-21 10:46:21.791088+00:00"},
+"16,1,3,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 84.1935076713562, "times": [84.33030700683594, 84.19059753417969, 84.1082534790039, 84.17720794677734, 84.18507385253906, 84.20679473876953, 84.28496551513672, 84.16939544677734, 84.17633056640625, 84.18934631347656, 84.37673950195312, 84.21024322509766, 84.10818481445312, 84.2208480834961, 84.17076873779297, 84.18907165527344, 84.10720825195312, 84.22223663330078, 84.15325164794922, 84.1522445678711, 84.23414611816406, 84.11605834960938, 84.22561645507812, 84.20122528076172, 84.16836547851562, 84.16991424560547, 84.15262603759766, 84.16314697265625, 84.24617767333984, 84.2310791015625, 84.19099426269531, 84.16382598876953], "compile_time": 2540.8975700847805, "verification_time": 0, "benchmark_time": 2695.836692582816, "GFLOP/s": 89.67137026135006, "strategy_time": 0, "framework_time": 1.7055431380867958, "timestamp": "2023-12-21 10:46:27.029543+00:00"},
+"16,1,3,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.9737583398819, "times": [40.915191650390625, 41.03883361816406, 41.0155143737793, 40.91568374633789, 40.93807601928711, 41.02110290527344, 40.8455924987793, 40.993186950683594, 40.89887619018555, 41.063419342041016, 41.0751953125, 40.955596923828125, 40.99791717529297, 40.90483093261719, 40.767032623291016, 40.98087692260742, 41.141117095947266, 41.12299728393555, 40.967037200927734, 40.95609664916992, 40.98991775512695, 40.94567108154297, 41.03711700439453, 40.9482421875, 40.90959548950195, 40.96308135986328, 41.057437896728516, 40.9342155456543, 41.01743698120117, 40.9106330871582, 40.91023635864258, 41.02250671386719], "compile_time": 1106.4427345991135, "verification_time": 0, "benchmark_time": 1312.8385529853404, "GFLOP/s": 184.25810825977945, "strategy_time": 0, "framework_time": 1.5653623268008232, "timestamp": "2023-12-21 10:46:29.450407+00:00"},
+"16,1,3,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.81668758392334, "times": [43.826107025146484, 43.873775482177734, 43.75218963623047, 43.76148223876953, 43.82258987426758, 43.74531173706055, 43.85746765136719, 43.77600860595703, 43.750587463378906, 43.69594955444336, 43.828826904296875, 43.73244857788086, 43.892669677734375, 43.81925582885742, 43.75314712524414, 43.83698272705078, 43.79058837890625, 43.85014724731445, 43.849788665771484, 43.817378997802734, 43.99603271484375, 43.896846771240234, 43.8561897277832, 43.85696029663086, 43.93794631958008, 43.812591552734375, 43.77410888671875, 43.84126663208008, 43.7681884765625, 43.78031921386719, 43.82450866699219, 43.75634002685547], "compile_time": 1102.5120532140136, "verification_time": 0, "benchmark_time": 1403.455554973334, "GFLOP/s": 172.30301093709457, "strategy_time": 0, "framework_time": 1.420570071786642, "timestamp": "2023-12-21 10:46:31.957811+00:00"},
+"16,1,3,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 96.90800595283508, "times": [96.88630676269531, 96.91295623779297, 97.01667022705078, 96.89561462402344, 96.9219970703125, 96.95030212402344, 96.9721908569336, 97.0907211303711, 96.87845611572266, 96.87798309326172, 96.9327621459961, 96.85127258300781, 96.97856903076172, 96.8322525024414, 96.97162628173828, 96.825439453125, 96.95724487304688, 96.82843780517578, 96.87572479248047, 96.86869049072266, 96.99122619628906, 96.81729125976562, 96.91134643554688, 96.94066619873047, 96.91020965576172, 96.83736419677734, 96.83068084716797, 96.8546142578125, 96.90495300292969, 96.90601348876953, 96.92790222167969, 96.8987045288086], "compile_time": 3021.820625755936, "verification_time": 0, "benchmark_time": 3102.6167389936745, "GFLOP/s": 77.90633112061397, "strategy_time": 0, "framework_time": 1.4512501657009125, "timestamp": "2023-12-21 10:46:38.083716+00:00"},
+"16,1,3,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 41.10373497009277, "times": [41.10399627685547, 41.27718734741211, 41.08431625366211, 41.0313720703125, 41.114715576171875, 41.1741828918457, 41.118717193603516, 40.983421325683594, 41.22607421875, 41.054683685302734, 41.17167663574219, 41.153724670410156, 41.13503646850586, 41.04334259033203, 41.025596618652344, 41.08993911743164, 41.152156829833984, 41.03744125366211, 41.12399673461914, 41.046695709228516, 41.04847717285156, 41.079872131347656, 41.09727478027344, 41.16056442260742, 41.093597412109375, 41.205509185791016, 41.166236877441406, 41.09825897216797, 40.88559341430664, 41.134578704833984, 41.29199981689453, 40.90928268432617], "compile_time": 1115.5566140078008, "verification_time": 0, "benchmark_time": 1316.9161793775856, "GFLOP/s": 183.67545444454677, "strategy_time": 0, "framework_time": 1.5415055677294731, "timestamp": "2023-12-21 10:46:40.517747+00:00"},
+"16,1,3,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 44.47050893306732, "times": [44.64787673950195, 44.48030471801758, 44.523555755615234, 44.43890380859375, 44.4808349609375, 44.405330657958984, 44.534114837646484, 44.47303771972656, 44.50771713256836, 44.55573654174805, 44.46867752075195, 44.39168930053711, 44.492515563964844, 44.47418212890625, 44.4005126953125, 44.421295166015625, 44.5225944519043, 44.44841766357422, 44.44707489013672, 44.37922286987305, 44.484676361083984, 44.455528259277344, 44.453311920166016, 44.48857498168945, 44.46563720703125, 44.561134338378906, 44.38003158569336, 44.418148040771484, 44.519554138183594, 44.451454162597656, 44.40291213989258, 44.481727600097656], "compile_time": 1094.9900173582137, "verification_time": 0, "benchmark_time": 1424.7890170663595, "GFLOP/s": 169.76975036114706, "strategy_time": 0, "framework_time": 1.5387097373604774, "timestamp": "2023-12-21 10:46:43.039080+00:00"},
+"16,1,3,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 95.16754817962646, "times": [95.19322967529297, 95.12812042236328, 95.08348083496094, 95.16831970214844, 95.15441131591797, 95.17240142822266, 95.17002868652344, 95.1973876953125, 95.24162292480469, 95.2347412109375, 95.14131164550781, 95.19440460205078, 95.20674133300781, 95.23958587646484, 95.18587493896484, 95.0804214477539, 95.19740295410156, 95.18177795410156, 95.14297485351562, 95.11693572998047, 95.12916564941406, 95.15959930419922, 95.1758804321289, 95.10625457763672, 95.09111022949219, 95.17536926269531, 95.21267700195312, 95.13424682617188, 95.27632141113281, 95.1484603881836, 95.1929702758789, 95.12831115722656], "compile_time": 1723.5169988125563, "verification_time": 0, "benchmark_time": 3046.948284842074, "GFLOP/s": 79.33110965252601, "strategy_time": 0, "framework_time": 1.5193130820989609, "timestamp": "2023-12-21 10:46:47.811081+00:00"},
+"16,1,3,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.522032737731934, "times": [16.688831329345703, 16.515230178833008, 16.52035140991211, 16.5148868560791, 16.50611114501953, 16.498750686645508, 16.486589431762695, 16.7168025970459, 16.505630493164062, 16.51043128967285, 16.493789672851562, 16.505996704101562, 16.53331184387207, 16.510271072387695, 16.524831771850586, 16.508136749267578, 16.5209903717041, 16.52851104736328, 16.510751724243164, 16.505998611450195, 16.510591506958008, 16.515871047973633, 16.527711868286133, 16.512248992919922, 16.503231048583984, 16.501951217651367, 16.507871627807617, 16.48598861694336, 16.4947509765625, 16.50851058959961, 16.521631240844727, 16.50848388671875], "compile_time": 847.2221102565527, "verification_time": 0, "benchmark_time": 530.3610130213201, "GFLOP/s": 456.95026270940514, "strategy_time": 0, "framework_time": 1.4028865844011307, "timestamp": "2023-12-21 10:46:49.190082+00:00"},
+"16,1,3,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.572364270687103, "times": [20.64375877380371, 20.58679962158203, 20.576398849487305, 20.5782527923584, 20.559438705444336, 20.56391716003418, 20.582637786865234, 20.567670822143555, 20.571918487548828, 20.563438415527344, 20.56903839111328, 20.562931060791016, 20.564558029174805, 20.562477111816406, 20.56711769104004, 20.557172775268555, 20.564237594604492, 20.555757522583008, 20.561355590820312, 20.565542221069336, 20.59815788269043, 20.611278533935547, 20.609037399291992, 20.560636520385742, 20.565038681030273, 20.566638946533203, 20.55447769165039, 20.567468643188477, 20.571598052978516, 20.564077377319336, 20.559438705444336, 20.56338882446289], "compile_time": 848.4169128350914, "verification_time": 0, "benchmark_time": 659.7814979031682, "GFLOP/s": 366.98490755179705, "strategy_time": 0, "framework_time": 1.4442880637943745, "timestamp": "2023-12-21 10:46:50.699740+00:00"},
+"16,1,3,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 93.68714690208435, "times": [93.70307922363281, 93.70482635498047, 93.67095947265625, 93.65332794189453, 93.66658020019531, 93.66031646728516, 93.69161224365234, 93.6751937866211, 93.69395446777344, 93.67607879638672, 93.68352508544922, 93.74569702148438, 93.71826934814453, 93.71017456054688, 93.6491928100586, 93.65657806396484, 93.84186553955078, 93.61217498779297, 93.69039154052734, 93.70086669921875, 93.66130828857422, 93.59038543701172, 93.75643920898438, 93.62696838378906, 93.70167541503906, 93.74605560302734, 93.7693862915039, 93.65709686279297, 93.64761352539062, 93.67780303955078, 93.73603820800781, 93.61326599121094], "compile_time": 2188.4728339500725, "verification_time": 0, "benchmark_time": 2999.5273747481406, "GFLOP/s": 80.58466342123215, "strategy_time": 0, "framework_time": 1.3168496079742908, "timestamp": "2023-12-21 10:46:55.889073+00:00"},
+"16,1,3,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.636627078056335, "times": [16.677791595458984, 16.657791137695312, 16.659391403198242, 16.66453742980957, 16.6461124420166, 16.65987205505371, 16.67603302001953, 16.662559509277344, 16.649951934814453, 16.64803123474121, 16.6595516204834, 16.65709114074707, 16.67571258544922, 16.655393600463867, 16.60211181640625, 16.593952178955078, 16.6147518157959, 16.62995147705078, 16.61075210571289, 16.64078712463379, 16.628992080688477, 16.631711959838867, 16.630273818969727, 16.5982666015625, 16.613792419433594, 16.61123275756836, 16.61907386779785, 16.620882034301758, 16.631071090698242, 16.614112854003906, 16.621631622314453, 16.608898162841797], "compile_time": 844.7655020281672, "verification_time": 0, "benchmark_time": 533.9485509321094, "GFLOP/s": 453.802754884017, "strategy_time": 0, "framework_time": 1.4543868601322174, "timestamp": "2023-12-21 10:46:57.269257+00:00"},
+"16,1,3,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.564409017562866, "times": [20.640398025512695, 20.59543800354004, 20.59575843811035, 20.59422492980957, 20.596878051757812, 20.576078414916992, 20.548555374145508, 20.56822395324707, 20.530315399169922, 20.540075302124023, 20.551916122436523, 20.539844512939453, 20.562637329101562, 20.544397354125977, 20.557998657226562, 20.543319702148438, 20.554798126220703, 20.53911781311035, 20.548877716064453, 20.544044494628906, 20.547277450561523, 20.543275833129883, 20.551918029785156, 20.539993286132812, 20.538957595825195, 20.545677185058594, 20.743600845336914, 20.55049705505371, 20.563438415527344, 20.562957763671875, 20.540075302124023, 20.560522079467773], "compile_time": 848.4388967044652, "verification_time": 0, "benchmark_time": 659.668168053031, "GFLOP/s": 367.12687408386984, "strategy_time": 0, "framework_time": 1.3571674935519695, "timestamp": "2023-12-21 10:46:58.778736+00:00"},
+"16,1,4,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.92837804555893, "times": [12.946228981018066, 12.926070213317871, 12.923990249633789, 12.923508644104004, 12.927664756774902, 12.92831039428711, 12.938228607177734, 12.930709838867188, 12.923829078674316, 12.926133155822754, 12.937429428100586, 12.926069259643555, 12.925748825073242, 12.929750442504883, 12.92224407196045, 12.93998908996582, 12.935829162597656, 12.92638874053955, 12.930069923400879, 12.928210258483887, 12.921109199523926, 12.930229187011719, 12.928950309753418, 12.92175006866455, 12.9320707321167, 12.920309066772461, 12.928309440612793, 12.919669151306152, 12.927349090576172, 12.928207397460938, 12.932470321655273, 12.921270370483398], "compile_time": 2952.168212737888, "verification_time": 0, "benchmark_time": 415.43381474912167, "GFLOP/s": 583.9670818253524, "strategy_time": 0, "framework_time": 1.3304478488862514, "timestamp": "2023-12-21 10:47:02.147684+00:00"},
+"16,1,4,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.50925862789154, "times": [11.535331726074219, 11.51533317565918, 11.507332801818848, 11.513092994689941, 11.506853103637695, 11.513792037963867, 11.514053344726562, 11.512292861938477, 11.514053344726562, 11.516133308410645, 11.513413429260254, 11.505866050720215, 11.508132934570312, 11.505892753601074, 11.507493019104004, 11.507013320922852, 11.50493335723877, 11.507162094116211, 11.507332801818848, 11.505573272705078, 11.509893417358398, 11.505892753601074, 11.503493309020996, 11.503724098205566, 11.506213188171387, 11.501413345336914, 11.508933067321777, 11.505573272705078, 11.508293151855469, 11.509978294372559, 11.50333309173584, 11.508453369140625], "compile_time": 654.9679259769619, "verification_time": 0, "benchmark_time": 369.6805532090366, "GFLOP/s": 655.9716350194739, "strategy_time": 0, "framework_time": 1.4228648506104946, "timestamp": "2023-12-21 10:47:03.173771+00:00"},
+"16,1,4,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.512028396129608, "times": [11.535012245178223, 11.508453369140625, 11.498852729797363, 11.71965503692627, 11.519173622131348, 11.499665260314941, 11.503493309020996, 11.515973091125488, 11.501893043518066, 11.508132934570312, 11.503493309020996, 11.504262924194336, 11.505413055419922, 11.51101303100586, 11.509893417358398, 11.505573272705078, 11.500932693481445, 11.501359939575195, 11.502693176269531, 11.502372741699219, 11.501572608947754, 11.50013256072998, 11.502532005310059, 11.506181716918945, 11.500773429870605, 11.50765323638916, 11.50493335723877, 11.500452041625977, 11.502532958984375, 11.505047798156738, 11.493252754211426, 11.502532005310059], "compile_time": 651.5228147618473, "verification_time": 0, "benchmark_time": 369.6133499033749, "GFLOP/s": 655.813809713869, "strategy_time": 0, "framework_time": 1.371245365589857, "timestamp": "2023-12-21 10:47:04.196294+00:00"},
+"16,1,4,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.404351070523262, "times": [6.431272983551025, 6.403913974761963, 6.406313896179199, 6.402314186096191, 6.409674167633057, 6.401673793792725, 6.404074192047119, 6.401834011077881, 6.400393962860107, 6.400271892547607, 6.401673793792725, 6.402634143829346, 6.401673793792725, 6.405673980712891, 6.403594017028809, 6.4029541015625, 6.402313232421875, 6.402153968811035, 6.4029541015625, 6.401916027069092, 6.403754234313965, 6.403113842010498, 6.403113842010498, 6.406154155731201, 6.403433799743652, 6.404233932495117, 6.403754234313965, 6.4024739265441895, 6.406953811645508, 6.404342174530029, 6.403594017028809, 6.405034065246582], "compile_time": 670.472752302885, "verification_time": 0, "benchmark_time": 206.97645703330636, "GFLOP/s": 1178.846555546986, "strategy_time": 0, "framework_time": 1.374711748212576, "timestamp": "2023-12-21 10:47:05.075133+00:00"},
+"16,1,4,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.469433784484863, "times": [11.491332054138184, 11.467652320861816, 11.475172996520996, 11.46317195892334, 11.468292236328125, 11.458854675292969, 11.461413383483887, 11.464932441711426, 11.465413093566895, 11.464132308959961, 11.462211608886719, 11.465401649475098, 11.464452743530273, 11.65357494354248, 11.467013359069824, 11.466373443603516, 11.467013359069824, 11.46120834350586, 11.459172248840332, 11.45709228515625, 11.4596529006958, 11.4642915725708, 11.467653274536133, 11.453787803649902, 11.464932441711426, 11.459651947021484, 11.456132888793945, 11.455331802368164, 11.462532997131348, 11.459527015686035, 11.454853057861328, 11.459651947021484], "compile_time": 642.9073340259492, "verification_time": 0, "benchmark_time": 368.5518871061504, "GFLOP/s": 658.2493383599135, "strategy_time": 0, "framework_time": 1.2870929203927517, "timestamp": "2023-12-21 10:47:06.087894+00:00"},
+"16,1,4,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.459118217229843, "times": [11.488612174987793, 11.465731620788574, 11.457732200622559, 11.46045207977295, 11.459332466125488, 11.457768440246582, 11.456453323364258, 11.462532043457031, 11.458852767944336, 11.454373359680176, 11.461091995239258, 11.454694747924805, 11.45437240600586, 11.458691596984863, 11.459972381591797, 11.45709228515625, 11.456453323364258, 11.453359603881836, 11.467171669006348, 11.45549201965332, 11.45725154876709, 11.452292442321777, 11.45693302154541, 11.459322929382324, 11.458212852478027, 11.45709228515625, 11.458373069763184, 11.458372116088867, 11.453731536865234, 11.461623191833496, 11.460612297058105, 11.457733154296875], "compile_time": 643.1516068987548, "verification_time": 0, "benchmark_time": 368.4590673074126, "GFLOP/s": 658.8418983799519, "strategy_time": 0, "framework_time": 1.3418900780379772, "timestamp": "2023-12-21 10:47:07.100864+00:00"},
+"16,1,4,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.731627367436886, "times": [3.7866029739379883, 3.7248430252075195, 3.71828293800354, 3.7205231189727783, 3.7187631130218506, 3.719403028488159, 3.720362901687622, 3.724363088607788, 3.71828293800354, 3.7235629558563232, 3.7197229862213135, 3.72644305229187, 3.721482992172241, 3.723242998123169, 3.722282886505127, 3.725162982940674, 3.7209808826446533, 3.7256429195404053, 3.7206830978393555, 3.727242946624756, 3.725482940673828, 3.72644305229187, 3.721163034439087, 3.9088449478149414, 3.7430830001831055, 3.7246830463409424, 3.7235629558563232, 3.7256429195404053, 3.722443103790283, 3.7307629585266113, 3.7227630615234375, 3.729322910308838], "compile_time": 2033.7868453934789, "verification_time": 0, "benchmark_time": 120.90414483100176, "GFLOP/s": 2023.1782159925674, "strategy_time": 0, "framework_time": 1.3581006787717342, "timestamp": "2023-12-21 10:47:09.256929+00:00"},
+"16,1,4,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.318007931113243, "times": [6.352872848510742, 6.325193881988525, 6.315913200378418, 6.3144731521606445, 6.3123931884765625, 6.311913013458252, 6.3155927658081055, 6.314632892608643, 6.319433212280273, 6.314948081970215, 6.323432922363281, 6.313512802124023, 6.321033000946045, 6.320393085479736, 6.3125529289245605, 6.31639289855957, 6.3125529289245605, 6.318792819976807, 6.316873073577881, 6.3167548179626465, 6.316553115844727, 6.317673206329346, 6.318152904510498, 6.322793006896973, 6.315113067626953, 6.314793109893799, 6.318792819976807, 6.320713996887207, 6.319272994995117, 6.319231986999512, 6.3104729652404785, 6.313033103942871], "compile_time": 940.5800788663328, "verification_time": 0, "benchmark_time": 203.4637234173715, "GFLOP/s": 1194.9569045048227, "strategy_time": 0, "framework_time": 1.365605741739273, "timestamp": "2023-12-21 10:47:10.402355+00:00"},
+"16,1,4,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.318961575627327, "times": [6.353672981262207, 6.327593803405762, 6.323432922363281, 6.316712856292725, 6.333033084869385, 6.313512802124023, 6.313353061676025, 6.315913200378418, 6.311273097991943, 6.3151679039001465, 6.3175129890441895, 6.3144731521606445, 6.317352771759033, 6.3175129890441895, 6.3175129890441895, 6.321193218231201, 6.314632892608643, 6.31639289855957, 6.31783390045166, 6.319985866546631, 6.3179931640625, 6.320073127746582, 6.318472862243652, 6.316233158111572, 6.31415319442749, 6.3144731521606445, 6.315752983093262, 6.319272994995117, 6.3179931640625, 6.321177005767822, 6.318953037261963, 6.31415319442749], "compile_time": 941.0621826536953, "verification_time": 0, "benchmark_time": 203.50515330210328, "GFLOP/s": 1194.7765640987434, "strategy_time": 0, "framework_time": 1.394281629472971, "timestamp": "2023-12-21 10:47:11.548331+00:00"},
+"16,1,4,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.4821416661143303, "times": [3.753803014755249, 3.4869210720062256, 3.4721999168395996, 3.4752399921417236, 3.4709200859069824, 3.4699599742889404, 3.4704411029815674, 3.4717209339141846, 3.4709200859069824, 3.4749200344085693, 3.47268009185791, 3.4637200832366943, 3.4712400436401367, 3.4721999168395996, 3.471240997314453, 3.4728400707244873, 3.4730000495910645, 3.4719231128692627, 3.4733200073242188, 3.47268009185791, 3.477320909500122, 3.4741199016571045, 3.4731600284576416, 3.473479986190796, 3.4723598957061768, 3.4741199016571045, 3.4744410514831543, 3.4768409729003906, 3.4762001037597656, 3.4730000495910645, 3.475719928741455, 3.4758799076080322], "compile_time": 922.1134544350207, "verification_time": 0, "benchmark_time": 113.34988474845886, "GFLOP/s": 2168.1332708168216, "strategy_time": 0, "framework_time": 1.3199755921959877, "timestamp": "2023-12-21 10:47:12.585129+00:00"},
+"16,1,4,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.261463493108749, "times": [6.297671794891357, 6.269351959228516, 6.266152858734131, 6.261352062225342, 6.260072231292725, 6.265992164611816, 6.26535177230835, 6.268392086029053, 6.258471965789795, 6.264679908752441, 6.258633136749268, 6.2661519050598145, 6.258471965789795, 6.2591118812561035, 6.258633136749268, 6.263591766357422, 6.2570319175720215, 6.259432792663574, 6.258312225341797, 6.259005069732666, 6.255591869354248, 6.252552032470703, 6.2591118812561035, 6.2589521408081055, 6.260872840881348, 6.256072044372559, 6.257032871246338, 6.2565531730651855, 6.258633136749268, 6.25705099105835, 6.259592056274414, 6.2589521408081055], "compile_time": 925.0710550695658, "verification_time": 0, "benchmark_time": 202.08188518881798, "GFLOP/s": 1205.7480185437655, "strategy_time": 0, "framework_time": 1.3720756396651268, "timestamp": "2023-12-21 10:47:13.713670+00:00"},
+"16,1,4,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.263679563999176, "times": [6.288392066955566, 6.261672019958496, 6.2589521408081055, 6.255911827087402, 6.256552219390869, 6.258632183074951, 6.2656731605529785, 6.257032871246338, 6.2570319175720215, 6.259615898132324, 6.458795070648193, 6.2589521408081055, 6.258313179016113, 6.254152774810791, 6.257832050323486, 6.25927209854126, 6.252871990203857, 6.255271911621094, 6.260232925415039, 6.252799987792969, 6.256552219390869, 6.260073184967041, 6.255433082580566, 6.256392002105713, 6.258953094482422, 6.256711959838867, 6.254312038421631, 6.244552135467529, 6.252552032470703, 6.247389793395996, 6.25383186340332, 6.253032207489014], "compile_time": 926.785203628242, "verification_time": 0, "benchmark_time": 202.00055791065097, "GFLOP/s": 1205.321428540592, "strategy_time": 0, "framework_time": 1.4139572158455849, "timestamp": "2023-12-21 10:47:14.843884+00:00"},
+"16,1,4,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 95.11920642852783, "times": [99.41513061523438, 99.04302215576172, 91.00992584228516, 97.81731414794922, 95.30638885498047, 97.34294128417969, 99.34553527832031, 98.80160522460938, 94.17897033691406, 97.62640380859375, 95.8402328491211, 94.9480972290039, 92.20011138916016, 95.82244873046875, 90.06697082519531, 90.05657958984375, 89.84574127197266, 92.929443359375, 95.9591064453125, 97.88357543945312, 93.63803100585938, 101.39845275878906, 89.66716766357422, 99.7437744140625, 101.22589874267578, 89.81748962402344, 91.65170288085938, 94.74911499023438, 95.5057601928711, 89.92737579345703, 101.27777099609375, 89.77252197265625], "compile_time": 3298.760010395199, "verification_time": 0, "benchmark_time": 3045.404631178826, "GFLOP/s": 79.37142753259666, "strategy_time": 0, "framework_time": 1.4942213892936707, "timestamp": "2023-12-21 10:47:21.189559+00:00"},
+"16,1,4,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.893814980983734, "times": [16.073305130004883, 15.897784233093262, 15.880983352661133, 15.887457847595215, 15.886262893676758, 15.884344100952148, 15.874102592468262, 15.876954078674316, 15.877622604370117, 15.88226318359375, 15.873783111572266, 15.887886047363281, 15.883063316345215, 15.885783195495605, 15.878583908081055, 15.874451637268066, 15.887863159179688, 15.88066291809082, 15.87906265258789, 15.870780944824219, 16.077625274658203, 15.89090347290039, 15.879383087158203, 15.880162239074707, 15.885143280029297, 15.870742797851562, 15.881784439086914, 15.881038665771484, 15.8797025680542, 15.878103256225586, 15.89266300201416, 15.881826400756836], "compile_time": 841.4895571768284, "verification_time": 0, "benchmark_time": 510.3864138945937, "GFLOP/s": 475.0116450350622, "strategy_time": 0, "framework_time": 1.5625860542058945, "timestamp": "2023-12-21 10:47:22.543013+00:00"},
+"16,1,4,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.858609646558762, "times": [15.898422241210938, 15.862902641296387, 15.87202262878418, 15.86305046081543, 15.86258316040039, 15.852663040161133, 15.859703063964844, 15.848213195800781, 15.87026309967041, 15.851702690124512, 15.858902931213379, 15.849637031555176, 15.868502616882324, 15.84962272644043, 15.85522174835205, 15.860696792602539, 15.85394287109375, 15.85714340209961, 15.85730266571045, 15.848287582397461, 15.85234260559082, 15.854582786560059, 15.854422569274902, 15.851211547851562, 15.851543426513672, 15.855222702026367, 15.861143112182617, 15.85894775390625, 15.863383293151855, 15.857623100280762, 15.859703063964844, 15.854596138000488], "compile_time": 834.9727899767458, "verification_time": 0, "benchmark_time": 509.05948504805565, "GFLOP/s": 476.0661475540044, "strategy_time": 0, "framework_time": 1.3565258122980595, "timestamp": "2023-12-21 10:47:23.888418+00:00"},
+"16,1,4,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 100.29500269889832, "times": [100.59099578857422, 100.17638397216797, 100.17780303955078, 100.32637786865234, 100.26472473144531, 100.15560150146484, 100.46257781982422, 100.1212387084961, 100.29281616210938, 100.24392700195312, 100.10855102539062, 100.20893859863281, 100.20826721191406, 100.24690246582031, 100.1902084350586, 100.339111328125, 100.4415512084961, 100.3492660522461, 100.31212615966797, 100.34967803955078, 100.25806427001953, 100.29046630859375, 100.28916931152344, 100.35671997070312, 100.39440155029297, 100.28047943115234, 100.20191192626953, 100.34481048583984, 100.3838882446289, 100.30223083496094, 100.50740051269531, 100.26349639892578], "compile_time": 4154.582446906716, "verification_time": 0, "benchmark_time": 3211.1211363226175, "GFLOP/s": 75.27540751622044, "strategy_time": 0, "framework_time": 1.420710701495409, "timestamp": "2023-12-21 10:47:31.255558+00:00"},
+"16,1,4,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.431275844573975, "times": [15.781781196594238, 15.429777145385742, 15.42337703704834, 15.410897254943848, 15.416336059570312, 15.438576698303223, 15.412337303161621, 15.422897338867188, 15.418098449707031, 15.431085586547852, 15.41297721862793, 15.418577194213867, 15.41905689239502, 15.42769718170166, 15.419669151306152, 15.419536590576172, 15.42177677154541, 15.416016578674316, 15.419217109680176, 15.428085327148438, 15.414417266845703, 15.413296699523926, 15.418256759643555, 15.417137145996094, 15.414874076843262, 15.408976554870605, 15.426897048950195, 15.419696807861328, 15.416816711425781, 15.430970191955566, 15.416016578674316, 15.41569709777832], "compile_time": 839.1605368815362, "verification_time": 0, "benchmark_time": 495.428382884711, "GFLOP/s": 489.2497079335589, "strategy_time": 0, "framework_time": 1.4424133114516735, "timestamp": "2023-12-21 10:47:32.591606+00:00"},
+"16,1,4,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.809665769338608, "times": [17.014436721801758, 16.20162582397461, 16.19490623474121, 16.186626434326172, 16.18626594543457, 16.193466186523438, 16.192825317382812, 16.18238639831543, 16.010103225708008, 15.62578010559082, 15.62593936920166, 15.623483657836914, 15.630900382995605, 15.640179634094238, 15.644339561462402, 15.644304275512695, 15.627059936523438, 15.638259887695312, 15.633620262145996, 15.634028434753418, 15.628819465637207, 15.63521957397461, 15.632180213928223, 15.636808395385742, 15.63010025024414, 15.629619598388672, 15.624499320983887, 15.623725891113281, 15.636500358581543, 15.637140274047852, 15.63617992401123, 15.627973556518555], "compile_time": 836.5553333424032, "verification_time": 0, "benchmark_time": 507.37134693190455, "GFLOP/s": 477.53996258681445, "strategy_time": 0, "framework_time": 1.4031478203833103, "timestamp": "2023-12-21 10:47:33.936950+00:00"},
+"16,1,4,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.272929146885872, "times": [7.288242816925049, 7.249042987823486, 7.245842933654785, 7.266324043273926, 7.258004188537598, 7.265203952789307, 7.269043922424316, 7.46872615814209, 7.263541221618652, 7.267124176025391, 7.2655229568481445, 7.278163909912109, 7.255444049835205, 7.27480411529541, 7.263443946838379, 7.276884078979492, 7.270802974700928, 7.268215179443359, 7.265364170074463, 7.267283916473389, 7.266003131866455, 7.274484157562256, 7.267923831939697, 7.268243789672852, 7.2680840492248535, 7.26232385635376, 7.268185138702393, 7.267764091491699, 7.2620038986206055, 7.2709641456604, 7.266963958740234, 7.263762950897217], "compile_time": 1776.352670043707, "verification_time": 0, "benchmark_time": 234.54386740922928, "GFLOP/s": 1038.061425805675, "strategy_time": 0, "framework_time": 1.4018635265529156, "timestamp": "2023-12-21 10:47:35.949264+00:00"},
+"16,1,4,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 17.43358623981476, "times": [17.760204315185547, 17.437000274658203, 17.425159454345703, 17.437467575073242, 17.42852020263672, 17.40947914123535, 17.425800323486328, 17.435302734375, 17.441160202026367, 17.43316078186035, 17.421640396118164, 17.420696258544922, 17.424039840698242, 17.423240661621094, 17.419719696044922, 17.421052932739258, 17.422119140625, 17.430919647216797, 17.422439575195312, 17.42652130126953, 17.436199188232422, 17.413639068603516, 17.414119720458984, 17.40850067138672, 17.41699981689453, 17.420040130615234, 17.404199600219727, 17.412630081176758, 17.41107940673828, 17.424999237060547, 17.42020034790039, 17.4265079498291], "compile_time": 1138.2293049246073, "verification_time": 0, "benchmark_time": 559.5225100405514, "GFLOP/s": 433.05761053098274, "strategy_time": 0, "framework_time": 1.311939675360918, "timestamp": "2023-12-21 10:47:37.648343+00:00"},
+"16,1,4,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.56185531616211, "times": [19.588224411010742, 19.565664291381836, 19.5600643157959, 19.559423446655273, 19.54854393005371, 19.559104919433594, 19.55718421936035, 19.550811767578125, 19.561344146728516, 19.544063568115234, 19.55414390563965, 19.552257537841797, 19.54198455810547, 19.561824798583984, 19.54854393005371, 19.559412002563477, 19.55094337463379, 19.743427276611328, 19.55638313293457, 19.544200897216797, 19.5512638092041, 19.56598472595215, 19.555423736572266, 19.559947967529297, 19.54662322998047, 19.549503326416016, 19.557504653930664, 19.561023712158203, 19.554784774780273, 19.561023712158203, 19.5512638092041, 19.557472229003906], "compile_time": 1125.456194858998, "verification_time": 0, "benchmark_time": 627.5726463645697, "GFLOP/s": 385.9422880897375, "strategy_time": 0, "framework_time": 1.419578678905964, "timestamp": "2023-12-21 10:47:39.402806+00:00"},
+"16,1,4,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.1327965259552, "times": [19.397661209106445, 19.137659072875977, 19.127899169921875, 19.141136169433594, 19.19062042236328, 19.13014030456543, 19.173179626464844, 19.20537567138672, 19.18630027770996, 19.195419311523438, 19.178939819335938, 19.119937896728516, 19.1002197265625, 19.11125946044922, 19.115259170532227, 19.093168258666992, 19.112539291381836, 19.110780715942383, 19.090139389038086, 19.094268798828125, 19.11094093322754, 19.090139389038086, 19.08725929260254, 19.108518600463867, 19.122140884399414, 19.101980209350586, 19.100860595703125, 19.09180450439453, 19.118619918823242, 19.118940353393555, 19.104700088500977, 19.081680297851562], "compile_time": 1208.7297458201647, "verification_time": 0, "benchmark_time": 613.717591855675, "GFLOP/s": 394.59716146346676, "strategy_time": 0, "framework_time": 1.4030765742063522, "timestamp": "2023-12-21 10:47:41.226672+00:00"},
+"16,1,4,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 17.36435377597809, "times": [17.540199279785156, 17.3629207611084, 17.357160568237305, 17.34103775024414, 17.346439361572266, 17.34947967529297, 17.361799240112305, 17.35198974609375, 17.347240447998047, 17.346120834350586, 17.35811996459961, 17.358495712280273, 17.357959747314453, 17.362760543823242, 17.365480422973633, 17.349231719970703, 17.355079650878906, 17.34004020690918, 17.3510799407959, 17.347742080688477, 17.348039627075195, 17.355880737304688, 17.344039916992188, 17.35220718383789, 17.346120834350586, 17.340679168701172, 17.354280471801758, 17.5388240814209, 17.361160278320312, 17.34819984436035, 17.34947967529297, 17.370031356811523], "compile_time": 1137.4521609395742, "verification_time": 0, "benchmark_time": 557.3503449559212, "GFLOP/s": 434.78423080992206, "strategy_time": 0, "framework_time": 1.3899412006139755, "timestamp": "2023-12-21 10:47:42.922879+00:00"},
+"16,1,4,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 1, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.514918744564056, "times": [19.547264099121094, 19.525503158569336, 19.520383834838867, 19.518871307373047, 19.51862335205078, 19.506303787231445, 19.51750373840332, 19.505552291870117, 19.511104583740234, 19.516063690185547, 19.504703521728516, 19.512630462646484, 19.52342414855957, 19.51590347290039, 19.505023956298828, 19.507583618164062, 19.500383377075195, 19.520063400268555, 19.511743545532227, 19.52167510986328, 19.522144317626953, 19.514944076538086, 19.503583908081055, 19.50130844116211, 19.512863159179688, 19.523103713989258, 19.50966453552246, 19.522062301635742, 19.514463424682617, 19.521663665771484, 19.51478385925293, 19.506505966186523], "compile_time": 1122.9123193770647, "verification_time": 0, "benchmark_time": 625.929415691644, "GFLOP/s": 386.8705424204242, "strategy_time": 0, "framework_time": 1.336798071861267, "timestamp": "2023-12-21 10:47:44.673074+00:00"},
+"16,2,1,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.707615911960602, "times": [6.732555866241455, 6.706316947937012, 6.693996906280518, 6.70471715927124, 6.701196193695068, 6.705196857452393, 6.710476875305176, 6.708237171173096, 6.700236797332764, 6.704927921295166, 6.711916923522949, 6.70471715927124, 6.701837062835693, 6.702476978302002, 6.701355934143066, 6.716396808624268, 6.709677219390869, 6.7075958251953125, 6.721676826477051, 6.703701972961426, 6.702796936035156, 6.704397201538086, 6.702157020568848, 6.713356971740723, 6.7008771896362305, 6.7029571533203125, 6.711916923522949, 6.705196857452393, 6.70855712890625, 6.7146100997924805, 6.712717056274414, 6.714957237243652], "compile_time": 654.73100123927, "verification_time": 0, "benchmark_time": 215.95154888927937, "GFLOP/s": 1125.5485256002453, "strategy_time": 0, "framework_time": 1.3730782084167004, "timestamp": "2023-12-21 10:47:45.545144+00:00"},
+"16,2,1,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.690896183252335, "times": [10.712282180786133, 10.690201759338379, 10.691322326660156, 10.684601783752441, 10.926204681396484, 10.686017990112305, 10.684282302856445, 10.683643341064453, 10.678361892700195, 10.68396282196045, 10.68332290649414, 10.683032989501953, 10.68188190460205, 10.679001808166504, 10.675962448120117, 10.678841590881348, 10.681402206420898, 10.681482315063477, 10.683161735534668, 10.680282592773438, 10.681722640991211, 10.687643051147461, 10.680282592773438, 10.682619094848633, 10.68076229095459, 10.678841590881348, 10.68220329284668, 10.678043365478516, 10.681082725524902, 10.681659698486328, 10.682202339172363, 10.682361602783203], "compile_time": 328.588442876935, "verification_time": 0, "benchmark_time": 343.8443709164858, "GFLOP/s": 706.1846893459638, "strategy_time": 0, "framework_time": 1.4770911075174809, "timestamp": "2023-12-21 10:47:46.219070+00:00"},
+"16,2,1,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.652186006307602, "times": [10.677401542663574, 10.652602195739746, 10.6463623046875, 10.6548433303833, 10.653081893920898, 10.655919075012207, 10.649882316589355, 10.653081893920898, 10.652762413024902, 10.64908218383789, 10.648921966552734, 10.645633697509766, 10.648282051086426, 10.648921966552734, 10.64908218383789, 10.651322364807129, 10.653882026672363, 10.652265548706055, 10.653081893920898, 10.64908218383789, 10.654682159423828, 10.651001930236816, 10.6497220993042, 10.652175903320312, 10.655482292175293, 10.647961616516113, 10.651322364807129, 10.652762413024902, 10.648761749267578, 10.654740333557129, 10.654521942138672, 10.651322364807129], "compile_time": 329.1583959944546, "verification_time": 0, "benchmark_time": 342.16432785615325, "GFLOP/s": 708.7509733241121, "strategy_time": 0, "framework_time": 1.3386528007686138, "timestamp": "2023-12-21 10:47:46.891746+00:00"},
+"16,2,1,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.8419781997799873, "times": [3.452838897705078, 3.427398920059204, 3.42084002494812, 3.416999101638794, 3.4185988903045654, 3.4237189292907715, 3.420198917388916, 3.4229190349578857, 3.4184389114379883, 3.4189200401306152, 3.4224390983581543, 3.419239044189453, 3.4237189292907715, 3.4182798862457275, 16.832965850830078, 3.4360389709472656, 3.424038887023926, 3.420520067214966, 3.4193990230560303, 3.4195590019226074, 3.42084002494812, 3.423719882965088, 3.4267590045928955, 3.420358896255493, 3.422600030899048, 3.4217989444732666, 3.4214789867401123, 3.420520067214966, 3.4195590019226074, 3.4195590019226074, 3.4265990257263184, 3.4224390983581543], "compile_time": 349.77790899574757, "verification_time": 0, "benchmark_time": 124.48184797540307, "GFLOP/s": 1965.0676832139077, "strategy_time": 0, "framework_time": 1.250280998647213, "timestamp": "2023-12-21 10:47:47.367272+00:00"},
+"16,2,1,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.677763223648071, "times": [10.702522277832031, 10.681721687316895, 10.676281929016113, 10.672602653503418, 10.676443099975586, 10.671280860900879, 10.671483039855957, 10.671643257141113, 10.671642303466797, 10.670682907104492, 10.669562339782715, 10.669060707092285, 10.669722557067871, 10.66556167602539, 10.669403076171875, 10.671643257141113, 10.675642967224121, 10.672905921936035, 10.676922798156738, 10.683161735534668, 10.674522399902344, 10.675163269042969, 10.67180347442627, 10.672228813171387, 10.67324161529541, 10.776603698730469, 10.676122665405273, 10.6780424118042, 10.680763244628906, 10.674836158752441, 10.672761917114258, 10.672442436218262], "compile_time": 325.87651209905744, "verification_time": 0, "benchmark_time": 343.50147703662515, "GFLOP/s": 707.0532509355099, "strategy_time": 0, "framework_time": 1.4023357070982456, "timestamp": "2023-12-21 10:47:48.038066+00:00"},
+"16,2,1,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.646113634109497, "times": [10.66908073425293, 10.648282051086426, 10.646041870117188, 10.645562171936035, 10.645562171936035, 10.644430160522461, 10.64380168914795, 10.64476203918457, 10.643321990966797, 10.644122123718262, 10.64204216003418, 10.643166542053223, 10.643482208251953, 10.644922256469727, 10.64380168914795, 10.6463623046875, 10.639001846313477, 10.64395809173584, 10.645082473754883, 10.649401664733887, 10.642681121826172, 10.647642135620117, 10.646681785583496, 10.645387649536133, 10.64364242553711, 10.651481628417969, 10.646681785583496, 10.639962196350098, 10.648282051086426, 10.642281532287598, 10.656601905822754, 10.64812183380127], "compile_time": 324.93085227906704, "verification_time": 0, "benchmark_time": 341.9368276372552, "GFLOP/s": 709.1552334939458, "strategy_time": 0, "framework_time": 1.327690202742815, "timestamp": "2023-12-21 10:47:48.706278+00:00"},
+"16,2,1,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.0026208199560642, "times": [2.034101963043213, 2.0038630962371826, 2.0075430870056152, 1.9979430437088013, 1.9961830377578735, 1.9976229667663574, 1.994102954864502, 2.0006630420684814, 1.9974629878997803, 1.9976229667663574, 1.9955430030822754, 1.9963430166244507, 1.9957029819488525, 2.00018310546875, 1.994102954864502, 1.9974629878997803, 1.9942630529403687, 1.9982630014419556, 1.9960230588912964, 1.9944219589233398, 1.9859429597854614, 1.9968229532241821, 2.1417839527130127, 1.999703049659729, 1.9957029819488525, 1.997143030166626, 1.9939429759979248, 2.00018310546875, 1.9955430030822754, 1.996662974357605, 1.996433973312378, 1.994583010673523], "compile_time": 426.3465288095176, "verification_time": 0, "benchmark_time": 66.03837199509144, "GFLOP/s": 3769.9334416016086, "strategy_time": 0, "framework_time": 1.3210582546889782, "timestamp": "2023-12-21 10:47:49.199999+00:00"},
+"16,2,1,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.11128406226635, "times": [6.145989894866943, 6.112870216369629, 6.111269950866699, 6.107590198516846, 6.110630035400391, 6.105830192565918, 6.106790065765381, 6.115910053253174, 6.1095099449157715, 6.1074299812316895, 6.110404014587402, 6.109189987182617, 6.1074299812316895, 6.108069896697998, 6.119589805603027, 6.114950180053711, 6.109350204467773, 6.1115899085998535, 6.106470108032227, 6.112709999084473, 6.112390041351318, 6.105225086212158, 6.108389854431152, 6.107590198516846, 6.109670162200928, 6.108389854431152, 6.1144700050354, 6.114150047302246, 6.112390041351318, 6.106470108032227, 6.111269950866699, 6.107110023498535], "compile_time": 379.550744779408, "verification_time": 0, "benchmark_time": 196.81249279528856, "GFLOP/s": 1235.37821562171, "strategy_time": 0, "framework_time": 1.165375579148531, "timestamp": "2023-12-21 10:47:49.777543+00:00"},
+"16,2,1,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.089783221483231, "times": [6.115269184112549, 6.089670181274414, 6.085830211639404, 6.081189155578613, 6.085830211639404, 6.082630157470703, 6.0831098556518555, 6.084070205688477, 6.080708980560303, 6.080870151519775, 6.084479808807373, 6.083270072937012, 6.082630157470703, 6.083909034729004, 6.083748817443848, 6.0850300788879395, 6.082950115203857, 6.083748817443848, 6.084229946136475, 6.082469940185547, 6.08390998840332, 6.082808971405029, 6.0831098556518555, 6.08342981338501, 6.080869197845459, 6.082629203796387, 6.241352081298828, 6.086949825286865, 6.083590030670166, 6.088069915771484, 6.084228992462158, 6.086470127105713], "compile_time": 380.66799798980355, "verification_time": 0, "benchmark_time": 196.52637792751193, "GFLOP/s": 1239.739893099377, "strategy_time": 0, "framework_time": 1.1810362339019775, "timestamp": "2023-12-21 10:47:50.355934+00:00"},
+"16,2,1,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.0005023144185543, "times": [2.0336220264434814, 2.010422945022583, 2.001462936401367, 1.9977829456329346, 1.9984229803085327, 1.9985829591751099, 1.9977829456329346, 1.9981030225753784, 1.9979430437088013, 1.9974629878997803, 1.9981030225753784, 2.003222942352295, 2.0005030632019043, 1.9976229667663574, 1.9982620477676392, 2.000343084335327, 1.997143030166626, 1.9979430437088013, 1.997143030166626, 1.9973030090332031, 1.9976229667663574, 1.99058198928833, 2.001142978668213, 1.9989030361175537, 1.9969830513000488, 1.9982630014419556, 1.999222993850708, 2.0046629905700684, 1.999703049659729, 2.0059430599212646, 2.0027239322662354, 2.001142978668213], "compile_time": 407.9399909824133, "verification_time": 0, "benchmark_time": 66.05272926390171, "GFLOP/s": 3773.9257513402736, "strategy_time": 0, "framework_time": 1.1994917877018452, "timestamp": "2023-12-21 10:47:50.831141+00:00"},
+"16,2,1,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.106049835681915, "times": [6.1354289054870605, 6.106629848480225, 6.104229927062988, 6.100870132446289, 6.103109836578369, 6.105828762054443, 6.107110023498535, 6.106949806213379, 6.103429794311523, 6.105830192565918, 6.101899147033691, 6.10359001159668, 6.101669788360596, 6.1043901443481445, 6.104869842529297, 6.103909969329834, 6.1043901443481445, 6.104229927062988, 6.104869842529297, 6.107269763946533, 6.103270053863525, 6.100958824157715, 6.106790065765381, 6.105989933013916, 6.102789878845215, 6.102789878845215, 6.109189987182617, 6.108069896697998, 6.109350204467773, 6.10791015625, 6.104549884796143, 6.1114301681518555], "compile_time": 373.6224169842899, "verification_time": 0, "benchmark_time": 196.66820392012596, "GFLOP/s": 1236.4372062411858, "strategy_time": 0, "framework_time": 1.157859805971384, "timestamp": "2023-12-21 10:47:51.402605+00:00"},
+"16,2,1,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.081394657492638, "times": [6.113348960876465, 6.086309909820557, 6.081510066986084, 6.077669143676758, 6.081669807434082, 6.081989765167236, 6.080709934234619, 6.08358907699585, 6.077989101409912, 6.078310012817383, 6.079401016235352, 6.083749771118164, 6.079750061035156, 6.079750061035156, 6.081028938293457, 6.079909801483154, 6.080389976501465, 6.081510066986084, 6.080069065093994, 6.07974910736084, 6.078629970550537, 6.080738067626953, 6.082469940185547, 6.079750061035156, 6.078629970550537, 6.0784687995910645, 6.078470230102539, 6.079909801483154, 6.080230236053467, 6.077989101409912, 6.080389022827148, 6.080550193786621], "compile_time": 373.589351773262, "verification_time": 0, "benchmark_time": 196.4234788902104, "GFLOP/s": 1241.449967516623, "strategy_time": 0, "framework_time": 1.4985119923949242, "timestamp": "2023-12-21 10:47:51.974131+00:00"},
+"16,2,1,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 58.614745020866394, "times": [58.854270935058594, 58.65594482421875, 58.665950775146484, 58.653724670410156, 58.61395263671875, 58.63945388793945, 58.607872009277344, 58.60212707519531, 58.59027099609375, 58.53833770751953, 58.59859085083008, 58.62008285522461, 58.625152587890625, 58.604854583740234, 58.62419128417969, 58.638938903808594, 58.607872009277344, 58.596920013427734, 58.54915237426758, 58.598541259765625, 58.58067321777344, 58.63511276245117, 58.57619094848633, 58.628292083740234, 58.605472564697266, 58.623504638671875, 58.57603073120117, 58.59550476074219, 58.61315155029297, 58.579402923583984, 58.59971237182617, 58.57258987426758], "compile_time": 3278.2762302085757, "verification_time": 0, "benchmark_time": 1877.1442212164402, "GFLOP/s": 128.8028668778197, "strategy_time": 0, "framework_time": 1.3121683150529861, "timestamp": "2023-12-21 10:47:57.130879+00:00"},
+"16,2,1,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.77210646867752, "times": [19.096538543701172, 18.797496795654297, 18.700054168701172, 18.74142074584961, 18.712053298950195, 18.795095443725586, 18.788055419921875, 18.9268798828125, 18.87941551208496, 18.78117561340332, 18.787416458129883, 18.78984832763672, 18.751733779907227, 18.7083740234375, 18.732694625854492, 18.72920036315918, 18.717493057250977, 18.778295516967773, 18.70725440979004, 18.7319278717041, 18.798616409301758, 18.754133224487305, 18.81541633605957, 18.749486923217773, 18.749013900756836, 18.684371948242188, 18.801496505737305, 18.772363662719727, 18.73029327392578, 18.776853561401367, 18.70053482055664, 18.722402572631836], "compile_time": 433.5313159972429, "verification_time": 0, "benchmark_time": 602.3728772997856, "GFLOP/s": 402.1790102563739, "strategy_time": 0, "framework_time": 1.3947300612926483, "timestamp": "2023-12-21 10:47:58.168195+00:00"},
+"16,2,1,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.909783720970154, "times": [19.237180709838867, 18.946136474609375, 18.909175872802734, 18.87596893310547, 18.95493507385254, 18.908536911010742, 18.876216888427734, 18.897653579711914, 18.928855895996094, 18.905176162719727, 18.903736114501953, 18.913360595703125, 18.85077667236328, 18.9066162109375, 18.865816116333008, 18.861915588378906, 18.95493507385254, 18.92581558227539, 18.84613609313965, 18.874704360961914, 18.88261604309082, 18.91685676574707, 18.923416137695312, 18.88880729675293, 18.885175704956055, 18.878616333007812, 18.914615631103516, 18.91866111755371, 18.86069679260254, 18.943416595458984, 18.888216018676758, 18.868335723876953], "compile_time": 432.2740728966892, "verification_time": 0, "benchmark_time": 606.59762006253, "GFLOP/s": 399.2508487353902, "strategy_time": 0, "framework_time": 1.3843420892953873, "timestamp": "2023-12-21 10:47:59.208466+00:00"},
+"16,2,1,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 60.09362816810608, "times": [60.19108963012695, 60.08354568481445, 60.03364944458008, 60.06355667114258, 60.096046447753906, 60.05801010131836, 60.09204864501953, 60.092838287353516, 60.12308883666992, 60.13092803955078, 60.040687561035156, 60.09201431274414, 60.11444854736328, 60.059810638427734, 60.035888671875, 60.08629608154297, 60.32501220703125, 60.10468673706055, 60.1342887878418, 60.11908721923828, 60.07828903198242, 60.053009033203125, 60.07076644897461, 60.094295501708984, 60.07748794555664, 60.08235549926758, 60.09956741333008, 60.09137725830078, 60.04148864746094, 60.0975341796875, 60.06596755981445, 60.06694030761719], "compile_time": 4201.3238510116935, "verification_time": 0, "benchmark_time": 1924.6693486347795, "GFLOP/s": 125.63307342469514, "strategy_time": 0, "framework_time": 1.3521085493266582, "timestamp": "2023-12-21 10:48:05.335834+00:00"},
+"16,2,1,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.72827696800232, "times": [18.98917579650879, 18.68869400024414, 18.724533081054688, 18.687631607055664, 18.742935180664062, 18.790935516357422, 18.71045684814453, 18.703227996826172, 18.773656845092773, 18.70133399963379, 18.672374725341797, 18.690887451171875, 18.647571563720703, 18.70565414428711, 18.724695205688477, 18.767824172973633, 18.71317481994629, 18.717016220092773, 18.652374267578125, 18.790538787841797, 18.724374771118164, 18.685014724731445, 18.71829605102539, 18.766639709472656, 18.781015396118164, 18.690134048461914, 18.753494262695312, 18.695392608642578, 18.66789436340332, 18.81221580505371, 18.666454315185547, 18.749244689941406], "compile_time": 430.6907360441983, "verification_time": 0, "benchmark_time": 600.8194382302463, "GFLOP/s": 403.12022365425884, "strategy_time": 0, "framework_time": 1.3866247609257698, "timestamp": "2023-12-21 10:48:06.368747+00:00"},
+"16,2,1,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.87554007768631, "times": [18.895095825195312, 18.94005584716797, 18.903255462646484, 18.911331176757812, 18.880535125732422, 18.857175827026367, 18.888856887817383, 18.906166076660156, 18.858776092529297, 18.83733558654785, 18.95573616027832, 18.80021095275879, 18.83429527282715, 18.916215896606445, 18.872215270996094, 18.851642608642578, 18.79925537109375, 18.821176528930664, 18.87557601928711, 18.87422752380371, 18.86533546447754, 18.863895416259766, 18.8072566986084, 18.838531494140625, 18.847095489501953, 19.055099487304688, 18.895095825195312, 18.876419067382812, 18.859895706176758, 18.901016235351562, 18.873336791992188, 18.85516929626465], "compile_time": 430.23013416677713, "verification_time": 0, "benchmark_time": 605.709059163928, "GFLOP/s": 399.97516197827485, "strategy_time": 0, "framework_time": 1.3156975619494915, "timestamp": "2023-12-21 10:48:07.406019+00:00"},
+"16,2,1,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.3926058821380138, "times": [1.4296159744262695, 1.400015950202942, 1.3969759941101074, 1.3953759670257568, 1.3926559686660767, 1.4001760482788086, 1.3907359838485718, 1.3923360109329224, 1.3904160261154175, 1.3880150318145752, 1.3880159854888916, 1.3937760591506958, 1.3872159719467163, 1.3937760591506958, 1.3928159475326538, 1.3902560472488403, 1.3880159854888916, 1.39409601688385, 1.3884960412979126, 1.3937760591506958, 1.389454960823059, 1.3902560472488403, 1.3896150588989258, 1.3896160125732422, 1.3905760049819946, 1.3942559957504272, 1.3884960412979126, 1.3881750106811523, 1.3896160125732422, 1.3886560201644897, 1.388335943222046, 1.3897759914398193], "compile_time": 565.0969529524446, "verification_time": 0, "benchmark_time": 46.40248231589794, "GFLOP/s": 5421.309285588515, "strategy_time": 0, "framework_time": 1.3687219470739365, "timestamp": "2023-12-21 10:48:08.018903+00:00"},
+"16,2,1,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.7146002799272537, "times": [3.7494819164276123, 3.7250020503997803, 3.7136430740356445, 3.716362953186035, 3.7112419605255127, 3.713002920150757, 3.713162899017334, 3.7091619968414307, 3.7094829082489014, 3.717323064804077, 3.713641881942749, 3.7131619453430176, 3.7094829082489014, 3.714282989501953, 3.712682008743286, 3.717802047729492, 3.7129321098327637, 3.7139620780944824, 3.709641933441162, 3.7107629776000977, 3.7109220027923584, 3.71572208404541, 3.711883068084717, 3.7157230377197266, 3.7141220569610596, 3.718441963195801, 3.712203025817871, 3.7091619968414307, 3.709481954574585, 3.716042995452881, 3.7154030799865723, 3.711883068084717], "compile_time": 475.75863311067224, "verification_time": 0, "benchmark_time": 119.97057590633631, "GFLOP/s": 2032.4521162605017, "strategy_time": 0, "framework_time": 1.301100943237543, "timestamp": "2023-12-21 10:48:08.615950+00:00"},
+"16,2,1,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.699396461248398, "times": [3.9571640491485596, 3.7026031017303467, 3.6952428817749023, 3.7026031017303467, 3.695241928100586, 3.6906020641326904, 3.6883630752563477, 3.6885221004486084, 3.68900203704834, 3.689321994781494, 3.688523054122925, 3.690922975540161, 3.692042112350464, 3.6904420852661133, 3.6941230297088623, 3.690922975540161, 3.6905710697174072, 3.68900203704834, 3.689162015914917, 3.688843011856079, 3.688041925430298, 3.692362070083618, 3.688361883163452, 3.68772292137146, 3.690282106399536, 3.6886820793151855, 3.6894819736480713, 3.687242031097412, 3.6912429332733154, 3.691401958465576, 3.692042112350464, 3.6906020641326904], "compile_time": 478.22424909099936, "verification_time": 0, "benchmark_time": 119.86907804384828, "GFLOP/s": 2040.8051094508164, "strategy_time": 0, "framework_time": 1.2135510332882404, "timestamp": "2023-12-21 10:48:09.215273+00:00"},
+"16,2,1,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.3976109996438026, "times": [1.4366559982299805, 1.4043370485305786, 1.3993760347366333, 1.3990559577941895, 1.3945759534835815, 1.3974560499191284, 1.3952159881591797, 1.3966560363769531, 1.3952159881591797, 1.3944159746170044, 1.396496057510376, 1.3944159746170044, 1.3968160152435303, 1.396496057510376, 1.3944159746170044, 1.3971359729766846, 1.3966560363769531, 1.398095965385437, 1.3956960439682007, 1.3995360136032104, 1.396496057510376, 1.3972959518432617, 1.395535945892334, 1.3931349515914917, 1.3953759670257568, 1.3944159746170044, 1.3942559957504272, 1.3971359729766846, 1.39409601688385, 1.3948960304260254, 1.3950560092926025, 1.3971359729766846], "compile_time": 516.8808777816594, "verification_time": 0, "benchmark_time": 46.79666506126523, "GFLOP/s": 5401.894519951646, "strategy_time": 0, "framework_time": 1.3695340603590012, "timestamp": "2023-12-21 10:48:09.780336+00:00"},
+"16,2,1,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.7166683450341225, "times": [3.7437219619750977, 3.7150819301605225, 3.7133231163024902, 3.7075629234313965, 3.707242965698242, 3.7101221084594727, 3.705482006072998, 3.7123630046844482, 3.7104430198669434, 3.913325071334839, 3.7178030014038086, 3.7109220027923584, 3.705641984939575, 3.7130019664764404, 3.7067630290985107, 3.705322027206421, 3.704709053039551, 3.7107620239257812, 3.7061219215393066, 3.7050020694732666, 3.7082018852233887, 3.711721897125244, 3.710123062133789, 3.7075629234313965, 3.712362051010132, 3.7078819274902344, 3.710123062133789, 3.7117230892181396, 3.7067630290985107, 3.705962896347046, 3.7091619968414307, 3.7070820331573486], "compile_time": 472.7656147442758, "verification_time": 0, "benchmark_time": 120.20032992586493, "GFLOP/s": 2031.3211992905667, "strategy_time": 0, "framework_time": 1.3539232313632965, "timestamp": "2023-12-21 10:48:10.374673+00:00"},
+"16,2,1,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.689836546778679, "times": [3.7261219024658203, 3.6958820819854736, 3.6907620429992676, 3.688683032989502, 3.6885221004486084, 3.687082052230835, 3.684683084487915, 3.6874020099639893, 3.6835620403289795, 3.6904420852661133, 3.6896419525146484, 3.68772292137146, 3.6866021156311035, 3.686121940612793, 3.689162015914917, 3.6920430660247803, 3.6904211044311523, 3.68628191947937, 3.6856420040130615, 3.697161912918091, 3.6864418983459473, 3.6899619102478027, 3.6894819736480713, 3.688683032989502, 3.6885221004486084, 3.6856420040130615, 3.689162015914917, 3.6890029907226562, 3.6885221004486084, 3.6867620944976807, 3.6894819736480713, 3.689162015914917], "compile_time": 474.61055871099234, "verification_time": 0, "benchmark_time": 119.60643110796809, "GFLOP/s": 2046.092585480818, "strategy_time": 0, "framework_time": 1.2996173463761806, "timestamp": "2023-12-21 10:48:10.970204+00:00"},
+"16,2,2,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.41755136847496, "times": [6.43431282043457, 6.413193225860596, 6.407113075256348, 6.407113075256348, 6.405673027038574, 6.406313896179199, 6.403594017028809, 6.409354209899902, 6.407594203948975, 6.4071760177612305, 6.404552936553955, 6.413193225860596, 6.4080729484558105, 6.406952857971191, 6.412073135375977, 6.415914058685303, 6.40903377532959, 6.412553787231445, 6.61543607711792, 6.416783809661865, 6.43575382232666, 6.411913871765137, 6.408874034881592, 6.4095139503479, 6.408392906188965, 6.406952857971191, 6.408553123474121, 6.408553123474121, 6.407752990722656, 6.409310817718506, 6.414154052734375, 6.415914058685303], "compile_time": 951.6314081847668, "verification_time": 0, "benchmark_time": 207.18555198982358, "GFLOP/s": 1176.4217793544658, "strategy_time": 0, "framework_time": 1.3126321136951447, "timestamp": "2023-12-21 10:48:12.130349+00:00"},
+"16,2,2,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.310234993696213, "times": [10.333558082580566, 10.316758155822754, 10.307478904724121, 10.307957649230957, 10.312918663024902, 10.310677528381348, 10.313157081604004, 10.313238143920898, 10.305237770080566, 10.307638168334961, 10.313878059387207, 10.307477951049805, 10.313878059387207, 10.305673599243164, 10.310037612915039, 10.312118530273438, 10.305878639221191, 10.310358047485352, 10.305559158325195, 10.305719375610352, 10.307975769042969, 10.311637878417969, 10.310677528381348, 10.311798095703125, 10.309078216552734, 10.309557914733887, 10.313398361206055, 10.308283805847168, 10.307638168334961, 10.30667781829834, 10.306678771972656, 10.30491828918457], "compile_time": 424.9849431216717, "verification_time": 0, "benchmark_time": 331.01972099393606, "GFLOP/s": 732.257529010347, "strategy_time": 0, "framework_time": 1.2432090006768703, "timestamp": "2023-12-21 10:48:12.887612+00:00"},
+"16,2,2,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.262095928192139, "times": [10.28011703491211, 10.260598182678223, 10.254677772521973, 10.258196830749512, 10.2545166015625, 10.256598472595215, 10.25748062133789, 10.255157470703125, 10.252437591552734, 10.255638122558594, 10.254837036132812, 10.260597229003906, 10.253717422485352, 10.251255989074707, 10.255956649780273, 10.249558448791504, 10.258036613464355, 10.256438255310059, 10.256596565246582, 10.2545166015625, 10.253783226013184, 10.2545166015625, 10.257396697998047, 10.255477905273438, 10.252436637878418, 10.25771713256836, 10.2532377243042, 10.445903778076172, 10.253397941589355, 10.255638122558594, 10.258676528930664, 10.251957893371582], "compile_time": 424.9554858542979, "verification_time": 0, "benchmark_time": 329.72613628953695, "GFLOP/s": 735.6925186461427, "strategy_time": 0, "framework_time": 1.2328880839049816, "timestamp": "2023-12-21 10:48:13.643542+00:00"},
+"16,2,2,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.372200518846512, "times": [3.4005179405212402, 3.3779590129852295, 3.371238946914673, 3.3733179569244385, 3.3680379390716553, 3.3699591159820557, 3.3685190677642822, 3.371558904647827, 3.3665990829467773, 3.3680388927459717, 3.369797945022583, 3.3696389198303223, 3.369478940963745, 3.3736391067504883, 3.372519016265869, 3.3757190704345703, 3.373958110809326, 3.371558904647827, 3.370337963104248, 3.3694779872894287, 3.37027907371521, 3.369158983230591, 3.3731589317321777, 3.3709189891815186, 3.3717188835144043, 3.3710789680480957, 3.3701179027557373, 3.3710780143737793, 3.370439052581787, 3.3721981048583984, 3.3755578994750977, 3.3728389739990234], "compile_time": 480.4100738838315, "verification_time": 0, "benchmark_time": 109.40402699634433, "GFLOP/s": 2238.8191798815246, "strategy_time": 0, "framework_time": 1.3631409965455532, "timestamp": "2023-12-21 10:48:14.234734+00:00"},
+"16,2,2,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.30204227566719, "times": [10.325557708740234, 10.305718421936035, 10.307638168334961, 10.299798011779785, 10.30475902557373, 10.29787826538086, 10.296181678771973, 10.297718048095703, 10.303478240966797, 10.30219841003418, 10.298678398132324, 10.304437637329102, 10.299637794494629, 10.307171821594238, 10.296757698059082, 10.301718711853027, 10.298837661743164, 10.306998252868652, 10.296757698059082, 10.296918869018555, 10.301778793334961, 10.307638168334961, 10.298837661743164, 10.305397987365723, 10.301557540893555, 10.301238059997559, 10.300118446350098, 10.298994064331055, 10.298197746276855, 10.299798011779785, 10.297718048095703, 10.305237770080566], "compile_time": 418.8242400996387, "verification_time": 0, "benchmark_time": 330.9991410933435, "GFLOP/s": 732.839858154344, "strategy_time": 0, "framework_time": 1.42569188028574, "timestamp": "2023-12-21 10:48:14.985999+00:00"},
+"16,2,2,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.256394445896149, "times": [10.276276588439941, 10.252917289733887, 10.50316047668457, 10.259157180786133, 10.246517181396484, 10.24555778503418, 10.245880126953125, 10.245877265930176, 10.24683666229248, 10.249076843261719, 10.247477531433105, 10.246196746826172, 10.250516891479492, 10.247034072875977, 10.254037857055664, 10.247958183288574, 10.243797302246094, 10.243477821350098, 10.240118026733398, 10.249077796936035, 10.246173858642578, 10.245556831359863, 10.242998123168945, 10.246196746826172, 10.242197036743164, 10.2545166015625, 10.25147819519043, 10.247687339782715, 10.24731731414795, 10.243956565856934, 10.246996879577637, 10.248597145080566], "compile_time": 419.4526979699731, "verification_time": 0, "benchmark_time": 329.78284545242786, "GFLOP/s": 736.1014867189367, "strategy_time": 0, "framework_time": 1.2853983789682388, "timestamp": "2023-12-21 10:48:15.736535+00:00"},
+"16,2,2,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.576259285211563, "times": [2.631869077682495, 2.585789918899536, 2.5680301189422607, 2.568510055541992, 2.5653090476989746, 2.576029062271118, 2.5729899406433105, 2.578749895095825, 2.5720300674438477, 2.570749044418335, 2.5806689262390137, 2.5673890113830566, 2.569469928741455, 2.5798699855804443, 2.5659499168395996, 2.573309898376465, 2.570590019226074, 2.582750082015991, 2.573949098587036, 2.571229934692383, 2.5672290325164795, 2.5757100582122803, 2.5840299129486084, 2.5697760581970215, 2.578749895095825, 2.576349973678589, 2.5699501037597656, 2.5795490741729736, 2.577630043029785, 2.574589967727661, 2.581789970397949, 2.579710006713867], "compile_time": 1148.2609300874174, "verification_time": 0, "benchmark_time": 83.72196927666664, "GFLOP/s": 2930.5075165910607, "strategy_time": 0, "framework_time": 1.220955979079008, "timestamp": "2023-12-21 10:48:16.969753+00:00"},
+"16,2,2,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.872813329100609, "times": [5.904067039489746, 5.868707180023193, 5.866627216339111, 5.866147041320801, 5.8637471199035645, 5.8648681640625, 5.8659868240356445, 5.863107204437256, 5.870787143707275, 5.8658270835876465, 5.8665900230407715, 6.067590236663818, 5.865187168121338, 5.865346908569336, 5.860386848449707, 5.864706993103027, 5.862786769866943, 5.872706890106201, 5.864387035369873, 5.861186981201172, 5.865187168121338, 5.869259834289551, 5.863907814025879, 5.866948127746582, 5.861506938934326, 5.866786956787109, 5.863586902618408, 5.8679070472717285, 5.865346908569336, 5.866147041320801, 5.8637471199035645, 5.858946800231934], "compile_time": 580.1028292626143, "verification_time": 0, "benchmark_time": 189.83441404998302, "GFLOP/s": 1285.5418309636966, "strategy_time": 0, "framework_time": 1.2305737473070621, "timestamp": "2023-12-21 10:48:17.740936+00:00"},
+"16,2,2,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.837283104658127, "times": [5.867745876312256, 5.8506269454956055, 5.837186813354492, 5.83286714553833, 5.834946155548096, 5.833666801452637, 5.836866855621338, 5.834146976470947, 5.843906879425049, 5.832067012786865, 5.836551189422607, 5.8343071937561035, 5.840227127075195, 5.834305763244629, 5.835587024688721, 5.841826915740967, 5.841026782989502, 5.834146976470947, 5.83510684967041, 5.838626861572266, 5.831747055053711, 5.832262992858887, 5.831427097320557, 5.839107036590576, 5.830946922302246, 5.839746952056885, 5.832547187805176, 5.835587024688721, 5.833186149597168, 5.839746952056885, 5.837347030639648, 5.833666801452637], "compile_time": 583.6677318438888, "verification_time": 0, "benchmark_time": 188.01569333299994, "GFLOP/s": 1293.3666338669327, "strategy_time": 0, "framework_time": 1.2482767924666405, "timestamp": "2023-12-21 10:48:18.513882+00:00"},
+"16,2,2,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.9885518811643124, "times": [2.012022018432617, 1.9838629961013794, 1.9790630340576172, 1.97890305519104, 1.9819430112838745, 1.9768229722976685, 1.9803420305252075, 1.9848220348358154, 1.9797019958496094, 1.976662039756775, 1.9811429977416992, 1.9869029521942139, 1.9792230129241943, 1.9838629961013794, 1.9806629419326782, 1.9821029901504517, 1.9821029901504517, 1.9853030443191528, 1.9819430112838745, 1.9805020093917847, 2.1705849170684814, 1.9888230562210083, 1.9827430248260498, 1.9795420169830322, 1.9848220348358154, 1.992182970046997, 1.980821967124939, 1.981942057609558, 1.9784220457077026, 1.9765030145645142, 1.9785829782485962, 1.980795979499817], "compile_time": 636.8083939887583, "verification_time": 0, "benchmark_time": 64.53125830739737, "GFLOP/s": 3796.6055960177237, "strategy_time": 0, "framework_time": 1.230322290211916, "timestamp": "2023-12-21 10:48:19.216467+00:00"},
+"16,2,2,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.863651946187019, "times": [5.893667221069336, 5.863266944885254, 5.864067077636719, 5.859746932983398, 5.857986927032471, 5.8658270835876465, 5.858946800231934, 5.861668109893799, 5.860547065734863, 5.864387035369873, 5.859450817108154, 5.862307071685791, 5.861186981201172, 5.860708236694336, 5.8658270835876465, 5.87094783782959, 5.863586902618408, 5.865026950836182, 5.8624677658081055, 5.860706806182861, 5.866147041320801, 5.86195707321167, 5.861987113952637, 5.862627029418945, 5.860867023468018, 5.870147228240967, 5.861667156219482, 5.8629469871521, 5.860066890716553, 5.860867023468018, 5.8639068603515625, 5.861347198486328], "compile_time": 579.8002541996539, "verification_time": 0, "benchmark_time": 189.2956318333745, "GFLOP/s": 1287.5503643952477, "strategy_time": 0, "framework_time": 1.188189722597599, "timestamp": "2023-12-21 10:48:19.986767+00:00"},
+"16,2,2,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.843059495091438, "times": [5.8683857917785645, 5.841026782989502, 5.835906982421875, 5.833187103271484, 5.835267066955566, 5.839746952056885, 5.8354268074035645, 5.839587211608887, 5.834466934204102, 5.83510684967041, 5.833211898803711, 5.835587024688721, 5.8323869705200195, 5.8343071937561035, 5.833187103271484, 5.835746765136719, 5.83510684967041, 5.830787181854248, 5.831747055053711, 5.834627151489258, 5.842627048492432, 5.832921028137207, 5.835746765136719, 5.84054708480835, 5.833026885986328, 5.839746952056885, 5.841667175292969, 5.842307090759277, 5.836067199707031, 6.025828838348389, 5.8394269943237305, 5.833187103271484], "compile_time": 578.9677817374468, "verification_time": 0, "benchmark_time": 188.35171358659863, "GFLOP/s": 1292.0880244916714, "strategy_time": 0, "framework_time": 1.239570789039135, "timestamp": "2023-12-21 10:48:20.755342+00:00"},
+"16,2,2,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 60.81140410900116, "times": [60.743896484375, 60.77675247192383, 60.85045623779297, 60.882694244384766, 60.713497161865234, 60.801151275634766, 60.7840576171875, 60.846317291259766, 60.888694763183594, 60.801734924316406, 60.77685546875, 60.80066680908203, 60.88421630859375, 60.787315368652344, 60.7304573059082, 60.746131896972656, 60.81669616699219, 60.90031814575195, 60.78677749633789, 60.794742584228516, 60.882774353027344, 60.70455551147461, 60.89445495605469, 60.79237747192383, 60.78325653076172, 60.78099060058594, 60.73397445678711, 60.81243896484375, 60.941341400146484, 60.87356185913086, 60.85093688964844, 60.800838470458984], "compile_time": 1693.4992079623044, "verification_time": 0, "benchmark_time": 1947.6906233467162, "GFLOP/s": 124.15018713377322, "strategy_time": 0, "framework_time": 1.276510301977396, "timestamp": "2023-12-21 10:48:24.397823+00:00"},
+"16,2,2,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 28.29252713918686, "times": [28.232324600219727, 28.35904312133789, 28.324655532836914, 28.321123123168945, 28.205764770507812, 28.369197845458984, 28.247364044189453, 28.190723419189453, 28.266820907592773, 28.392166137695312, 28.347684860229492, 28.23648452758789, 28.35712432861328, 28.26784324645996, 28.37455177307129, 28.37296485900879, 28.34096336364746, 28.31094741821289, 28.349763870239258, 28.26288414001465, 28.26420783996582, 28.368484497070312, 28.345924377441406, 28.195236206054688, 28.324323654174805, 28.26160430908203, 28.240236282348633, 28.311044692993164, 28.272483825683594, 28.2547607421875, 28.11728286743164, 28.274883270263672], "compile_time": 812.9842798225582, "verification_time": 0, "benchmark_time": 907.1529689244926, "GFLOP/s": 266.8459824341087, "strategy_time": 0, "framework_time": 1.4316122978925705, "timestamp": "2023-12-21 10:48:26.119409+00:00"},
+"16,2,2,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 28.326194286346436, "times": [28.24272346496582, 28.250244140625, 28.512428283691406, 28.29552459716797, 28.29120445251465, 28.478727340698242, 28.2337646484375, 28.28640365600586, 28.331180572509766, 28.4134464263916, 28.274883270263672, 28.310226440429688, 28.375843048095703, 28.4180850982666, 28.405519485473633, 28.261764526367188, 28.36432456970215, 28.360279083251953, 28.305763244628906, 28.331363677978516, 28.223901748657227, 28.26784324645996, 28.14256477355957, 28.33124351501465, 28.404964447021484, 28.272323608398438, 28.32550811767578, 28.3944034576416, 28.383203506469727, 28.346311569213867, 28.347684860229492, 28.25456428527832], "compile_time": 810.2198168635368, "verification_time": 0, "benchmark_time": 907.9389204271138, "GFLOP/s": 266.5288221806439, "strategy_time": 0, "framework_time": 1.3035750016570091, "timestamp": "2023-12-21 10:48:27.838887+00:00"},
+"16,2,2,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 59.5711874961853, "times": [59.630279541015625, 59.66716003417969, 59.67908477783203, 59.554847717285156, 59.569480895996094, 59.69682312011719, 59.52083969116211, 59.659149169921875, 59.46516036987305, 59.58999252319336, 59.53219985961914, 59.58592987060547, 59.74500274658203, 59.542144775390625, 59.512359619140625, 59.50746154785156, 59.569801330566406, 59.596717834472656, 59.58564376831055, 59.52060317993164, 59.532840728759766, 59.615928649902344, 59.551239013671875, 59.4495735168457, 59.43907928466797, 59.572540283203125, 59.55876159667969, 59.62799835205078, 59.62116241455078, 59.612953186035156, 59.54756164550781, 59.41767883300781], "compile_time": 1884.5890336669981, "verification_time": 0, "benchmark_time": 1907.8492340631783, "GFLOP/s": 126.73487834170595, "strategy_time": 0, "framework_time": 1.3330401852726936, "timestamp": "2023-12-21 10:48:31.632674+00:00"},
+"16,2,2,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 28.17383587360382, "times": [28.129440307617188, 28.165922164916992, 28.06827163696289, 28.201284408569336, 28.14256477355957, 28.247648239135742, 28.065601348876953, 28.0798397064209, 28.269596099853516, 28.138561248779297, 28.13808250427246, 28.162399291992188, 28.339204788208008, 28.099361419677734, 28.462656021118164, 28.283203125, 28.252004623413086, 28.2103328704834, 28.249284744262695, 28.209924697875977, 28.243499755859375, 28.11728286743164, 28.22736358642578, 27.902063369750977, 28.173442840576172, 28.15184211730957, 28.15209197998047, 28.05072021484375, 28.055362701416016, 28.19772720336914, 28.239364624023438, 28.136802673339844], "compile_time": 810.4806020855904, "verification_time": 0, "benchmark_time": 903.1265419907868, "GFLOP/s": 267.9701562070001, "strategy_time": 0, "framework_time": 1.4430838637053967, "timestamp": "2023-12-21 10:48:33.347740+00:00"},
+"16,2,2,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 28.141588389873505, "times": [28.157602310180664, 28.338083267211914, 28.079755783081055, 28.211204528808594, 28.200483322143555, 28.20402717590332, 27.999839782714844, 28.210403442382812, 28.18422508239746, 28.179363250732422, 28.107202529907227, 28.112619400024414, 28.12784194946289, 28.072160720825195, 27.96010398864746, 28.19680404663086, 28.214244842529297, 28.09432029724121, 28.16944122314453, 28.3115234375, 28.21639633178711, 28.04159927368164, 28.232803344726562, 28.21403694152832, 28.203523635864258, 28.11216163635254, 28.02356719970703, 28.008960723876953, 28.10000228881836, 28.134363174438477, 27.962400436401367, 28.149763107299805], "compile_time": 811.6453178226948, "verification_time": 0, "benchmark_time": 902.0029860548675, "GFLOP/s": 268.27722356697916, "strategy_time": 0, "framework_time": 1.560581848025322, "timestamp": "2023-12-21 10:48:35.062965+00:00"},
+"16,2,2,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.054989516735077, "times": [6.065508842468262, 6.048389911651611, 6.039109230041504, 6.042149066925049, 6.034149169921875, 6.052868843078613, 6.044229030609131, 6.052389144897461, 6.045508861541748, 6.036549091339111, 6.04201602935791, 6.043909072875977, 6.041189193725586, 6.043589115142822, 6.0509490966796875, 6.049989223480225, 6.057829856872559, 6.048709869384766, 6.065349102020264, 6.05574893951416, 6.044709205627441, 6.05220890045166, 6.060548782348633, 6.24727201461792, 6.050468921661377, 6.055909156799316, 6.041189193725586, 6.0488691329956055, 6.03718900680542, 6.04679012298584, 6.052069187164307, 6.062310218811035], "compile_time": 1045.4058912582695, "verification_time": 0, "benchmark_time": 195.17626892775297, "GFLOP/s": 1246.863793757799, "strategy_time": 0, "framework_time": 1.435489859431982, "timestamp": "2023-12-21 10:48:36.304998+00:00"},
+"16,2,2,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.684470385313034, "times": [3.8770039081573486, 3.6880431175231934, 3.6827619075775146, 3.679241895675659, 3.6766819953918457, 3.677001953125, 3.6786019802093506, 3.6774818897247314, 3.6763620376586914, 3.679882049560547, 3.677962064743042, 3.67732310295105, 3.67588210105896, 3.6774818897247314, 3.678602933883667, 3.6776421070098877, 3.6782240867614746, 3.6762020587921143, 3.6757218837738037, 3.6774818897247314, 3.6776421070098877, 3.6797220706939697, 3.678122043609619, 3.6784420013427734, 3.6765220165252686, 3.6758830547332764, 3.6797220706939697, 3.677802085876465, 3.676042079925537, 3.682281970977783, 3.677001953125, 3.6782820224761963], "compile_time": 956.7824299447238, "verification_time": 0, "benchmark_time": 119.62336907163262, "GFLOP/s": 2049.072569586842, "strategy_time": 0, "framework_time": 1.3156472705304623, "timestamp": "2023-12-21 10:48:37.382734+00:00"},
+"16,2,2,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.6668566465377808, "times": [3.7061219215393066, 3.6741220951080322, 3.6774818897247314, 3.6664419174194336, 3.6640419960021973, 3.665802001953125, 3.662921905517578, 3.664841890335083, 3.6742820739746094, 3.6662819385528564, 3.665642023086548, 3.6651620864868164, 3.665802001953125, 3.670121908187866, 3.664201021194458, 3.666922092437744, 3.6627519130706787, 3.6645219326019287, 3.6640419960021973, 3.66388201713562, 3.663562059402466, 3.6630818843841553, 3.66388201713562, 3.662921905517578, 3.6630818843841553, 3.6632421016693115, 3.6654820442199707, 3.663562059402466, 3.6642019748687744, 3.6624419689178467, 3.663562059402466, 3.6650021076202393], "compile_time": 953.682818915695, "verification_time": 0, "benchmark_time": 119.35083009302616, "GFLOP/s": 2058.9152856925607, "strategy_time": 0, "framework_time": 1.4779320918023586, "timestamp": "2023-12-21 10:48:38.457262+00:00"},
+"16,2,2,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.434826008975506, "times": [4.010765075683594, 3.436678886413574, 3.4112389087677, 3.420358896255493, 3.407078981399536, 3.4166789054870605, 3.4125189781188965, 3.41395902633667, 3.427079916000366, 3.4133191108703613, 3.4073989391326904, 3.4073989391326904, 3.416038990020752, 3.413158893585205, 3.4094789028167725, 3.4219589233398438, 3.4115591049194336, 3.4090559482574463, 3.413158893585205, 3.418919086456299, 3.41395902633667, 3.424038887023926, 3.4081990718841553, 3.414119005203247, 3.4217989444732666, 3.4155590534210205, 3.4278790950775146, 3.425800085067749, 3.414918899536133, 3.424038887023926, 3.4134790897369385, 3.412838935852051], "compile_time": 1082.3053331114352, "verification_time": 0, "benchmark_time": 111.62724485620856, "GFLOP/s": 2197.999892941255, "strategy_time": 0, "framework_time": 1.3868850655853748, "timestamp": "2023-12-21 10:48:39.652596+00:00"},
+"16,2,2,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.6790659427642822, "times": [3.7213220596313477, 3.6864430904388428, 3.6803629398345947, 3.6824419498443604, 3.679241895675659, 3.6776421070098877, 3.677001953125, 3.6794021129608154, 3.6816420555114746, 3.6784420013427734, 3.678122043609619, 3.674762010574341, 3.6776421070098877, 3.6786019802093506, 3.6752419471740723, 3.6766819953918457, 3.674243927001953, 3.67588210105896, 3.6741220951080322, 3.6744420528411865, 3.675081968307495, 3.677001953125, 3.6765220165252686, 3.676362991333008, 3.674921989440918, 3.6752419471740723, 3.67588210105896, 3.676362991333008, 3.6755619049072266, 3.6757218837738037, 3.6752419471740723, 3.6925220489501953], "compile_time": 955.9653089381754, "verification_time": 0, "benchmark_time": 119.58548473194242, "GFLOP/s": 2052.082598532459, "strategy_time": 0, "framework_time": 1.4552576467394829, "timestamp": "2023-12-21 10:48:40.729618+00:00"},
+"16,2,2,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.669103130698204, "times": [3.7000420093536377, 3.6672420501708984, 3.6634020805358887, 3.661802053451538, 3.6614809036254883, 3.661642074584961, 3.658921957015991, 3.6600420475006104, 3.662921905517578, 3.8870840072631836, 3.6621220111846924, 3.657802104949951, 3.6622819900512695, 3.658761978149414, 3.656682014465332, 3.6621220111846924, 3.657676935195923, 3.6654820442199707, 3.658761978149414, 3.6602020263671875, 3.657641887664795, 3.665961980819702, 3.664681911468506, 3.6594018936157227, 3.6581220626831055, 3.663722038269043, 3.6574819087982178, 3.6621220111846924, 3.6582820415496826, 3.6613221168518066, 3.657802104949951, 3.6582820415496826], "compile_time": 954.6576458960772, "verification_time": 0, "benchmark_time": 119.2617379128933, "GFLOP/s": 2057.6546722913554, "strategy_time": 0, "framework_time": 1.4394065365195274, "timestamp": "2023-12-21 10:48:41.804993+00:00"},
+"16,2,3,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 68.52445888519287, "times": [68.60916137695312, 68.47451782226562, 68.58772277832031, 68.58355712890625, 68.49562072753906, 68.54479217529297, 68.47223663330078, 68.44693756103516, 68.62007904052734, 68.535888671875, 68.51329040527344, 68.52259063720703, 68.44961547851562, 68.56631469726562, 68.46994018554688, 68.62094116210938, 68.53472137451172, 68.57481384277344, 68.5409164428711, 68.4773178100586, 68.43775939941406, 68.61548614501953, 68.50943756103516, 68.5826416015625, 68.45738220214844, 68.44840240478516, 68.45484924316406, 68.48477172851562, 68.51667022705078, 68.65414428710938, 68.49219512939453, 68.48796844482422], "compile_time": 2374.940649140626, "verification_time": 0, "benchmark_time": 2194.338901899755, "GFLOP/s": 110.17594772472387, "strategy_time": 0, "framework_time": 1.33410282433033, "timestamp": "2023-12-21 10:48:46.375621+00:00"},
+"16,2,3,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 27.948743104934692, "times": [27.962400436401367, 28.004959106445312, 27.99998664855957, 27.898719787597656, 27.92736053466797, 27.999544143676758, 27.93791961669922, 27.957120895385742, 27.93545150756836, 27.880159378051758, 27.967519760131836, 27.931299209594727, 27.9335994720459, 27.953279495239258, 27.898305892944336, 27.954879760742188, 27.923839569091797, 27.944934844970703, 28.136642456054688, 27.921600341796875, 27.936769485473633, 27.928319931030273, 27.922239303588867, 27.96669578552246, 27.916799545288086, 27.977279663085938, 27.909412384033203, 27.924480438232422, 27.94384002685547, 27.980899810791016, 27.936960220336914, 27.94655990600586], "compile_time": 550.1902662217617, "verification_time": 0, "benchmark_time": 895.9756353870034, "GFLOP/s": 270.12832640287854, "strategy_time": 0, "framework_time": 1.5361444093286991, "timestamp": "2023-12-21 10:48:47.823340+00:00"},
+"16,2,3,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 30.851366817951202, "times": [30.948991775512695, 30.857952117919922, 30.79285430908203, 30.82691192626953, 30.868032455444336, 30.82252311706543, 30.864511489868164, 30.81715202331543, 30.873380661010742, 30.91075325012207, 30.84467124938965, 30.820608139038086, 30.8222713470459, 30.82499122619629, 30.84736442565918, 30.838111877441406, 30.85651206970215, 30.824848175048828, 30.823711395263672, 30.893951416015625, 30.812976837158203, 30.842111587524414, 30.83443260192871, 30.842435836791992, 30.860992431640625, 30.9401912689209, 30.87372398376465, 30.846912384033203, 30.89203453063965, 30.815359115600586, 30.854751586914062, 30.84771156311035], "compile_time": 549.7744218446314, "verification_time": 0, "benchmark_time": 988.691268954426, "GFLOP/s": 244.71354039351985, "strategy_time": 0, "framework_time": 1.3999114744365215, "timestamp": "2023-12-21 10:48:49.363221+00:00"},
+"16,2,3,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 68.10554385185242, "times": [68.09638214111328, 68.13404083251953, 68.01073455810547, 68.0547103881836, 68.08898162841797, 68.10244750976562, 68.07164764404297, 67.9651107788086, 68.11592102050781, 68.1270523071289, 68.001220703125, 68.12267303466797, 68.02344512939453, 68.18093872070312, 68.10761260986328, 68.06259155273438, 68.13418579101562, 67.9946060180664, 68.10444641113281, 68.12018585205078, 68.1425552368164, 68.21663665771484, 68.03960418701172, 68.156005859375, 68.03005981445312, 68.04401397705078, 68.05573272705078, 68.4313735961914, 68.05632019042969, 68.24871826171875, 68.13484954833984, 68.20259857177734], "compile_time": 4727.382391225547, "verification_time": 0, "benchmark_time": 2181.1572168953717, "GFLOP/s": 110.85363647374578, "strategy_time": 0, "framework_time": 1.4950740151107311, "timestamp": "2023-12-21 10:48:56.273272+00:00"},
+"16,2,3,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 28.180663883686066, "times": [28.211042404174805, 28.196964263916016, 28.243574142456055, 28.248483657836914, 28.192964553833008, 28.22183609008789, 28.210084915161133, 28.230083465576172, 28.205793380737305, 28.21920394897461, 28.20608139038086, 28.22859001159668, 28.158721923828125, 28.18096160888672, 28.18927574157715, 28.14480209350586, 28.1395206451416, 28.15850830078125, 28.1766414642334, 28.2033634185791, 28.150911331176758, 28.111040115356445, 28.136320114135742, 28.154020309448242, 28.19392204284668, 28.161121368408203, 28.160619735717773, 28.142562866210938, 28.15888214111328, 28.1645450592041, 28.126880645751953, 28.153921127319336], "compile_time": 548.7018940038979, "verification_time": 0, "benchmark_time": 903.4227463416755, "GFLOP/s": 267.90522860501477, "strategy_time": 0, "framework_time": 1.4677727594971657, "timestamp": "2023-12-21 10:48:57.726881+00:00"},
+"16,2,3,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 30.930044412612915, "times": [31.027393341064453, 30.975873947143555, 30.95624351501465, 30.971393585205078, 30.912353515625, 30.948204040527344, 30.927072525024414, 30.886592864990234, 30.90985679626465, 30.93635368347168, 30.916194915771484, 30.88136863708496, 30.935394287109375, 30.96307373046875, 30.902027130126953, 30.92963218688965, 30.919713973999023, 30.90934944152832, 30.889631271362305, 30.936513900756836, 30.910951614379883, 30.94051170349121, 30.92323112487793, 30.91546058654785, 30.959074020385742, 30.898271560668945, 30.940370559692383, 30.92259407043457, 30.9334716796875, 30.909900665283203, 30.918432235717773, 30.954914093017578], "compile_time": 551.6308369114995, "verification_time": 0, "benchmark_time": 991.3228950463235, "GFLOP/s": 244.09105590942184, "strategy_time": 0, "framework_time": 1.4249887317419052, "timestamp": "2023-12-21 10:48:59.271275+00:00"},
+"16,2,3,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 60.55798006057739, "times": [60.60917282104492, 60.584930419921875, 60.50917053222656, 60.9178466796875, 60.52757263183594, 60.551361083984375, 60.50933074951172, 60.543460845947266, 60.54133224487305, 60.49319839477539, 60.485652923583984, 60.50564956665039, 60.50693130493164, 60.518863677978516, 60.55989074707031, 60.573448181152344, 60.513492584228516, 60.556888580322266, 60.54661178588867, 60.59055709838867, 60.538612365722656, 60.595672607421875, 60.515892028808594, 60.581031799316406, 60.545013427734375, 60.4913444519043, 60.546932220458984, 60.58695983886719, 60.617332458496094, 60.58378219604492, 60.568050384521484, 60.53937530517578], "compile_time": 1654.421848244965, "verification_time": 0, "benchmark_time": 1939.426951110363, "GFLOP/s": 124.66973291460236, "strategy_time": 0, "framework_time": 1.4090575277805328, "timestamp": "2023-12-21 10:49:02.866548+00:00"},
+"16,2,3,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 37.154441118240356, "times": [37.46378707885742, 37.21175765991211, 37.13066482543945, 37.19142532348633, 37.0917854309082, 37.11810302734375, 37.12810516357422, 37.196041107177734, 37.11418533325195, 37.229549407958984, 37.16458511352539, 37.1334114074707, 37.11626434326172, 37.17488479614258, 37.210025787353516, 37.10081481933594, 37.13034439086914, 37.18281555175781, 37.08650588989258, 37.14903259277344, 37.15898513793945, 37.10646438598633, 37.13722229003906, 37.17942428588867, 37.16602325439453, 37.191139221191406, 37.11114501953125, 37.01707458496094, 37.134342193603516, 37.13159942626953, 37.10762405395508, 37.17698287963867], "compile_time": 877.2513680160046, "verification_time": 0, "benchmark_time": 1190.4623783193529, "GFLOP/s": 203.1990516550544, "strategy_time": 0, "framework_time": 1.4822287485003471, "timestamp": "2023-12-21 10:49:04.935760+00:00"},
+"16,2,3,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 42.168025851249695, "times": [42.21712112426758, 42.1785774230957, 42.07727813720703, 42.13627624511719, 42.09632110595703, 42.29694366455078, 42.1580810546875, 42.12412643432617, 42.06991958618164, 42.170257568359375, 42.09584045410156, 42.17226028442383, 42.48304748535156, 42.094581604003906, 42.21984100341797, 42.19220733642578, 42.188480377197266, 42.15385437011719, 42.17264175415039, 42.108238220214844, 42.067039489746094, 42.158565521240234, 42.15167999267578, 42.17892837524414, 42.18368148803711, 42.19509506225586, 42.16304016113281, 42.164974212646484, 42.194881439208984, 42.20069885253906, 42.11119842529297, 42.201148986816406], "compile_time": 882.6655112206936, "verification_time": 0, "benchmark_time": 1351.0619131848216, "GFLOP/s": 179.0396170461524, "strategy_time": 0, "framework_time": 1.4419527724385262, "timestamp": "2023-12-21 10:49:07.170945+00:00"},
+"16,2,3,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 59.83706438541412, "times": [59.8675651550293, 59.84513473510742, 59.8510856628418, 59.8631477355957, 59.82148361206055, 59.86780548095703, 59.82692337036133, 59.87113571166992, 59.816524505615234, 59.77377700805664, 59.76276397705078, 59.89325714111328, 59.76836395263672, 59.79680633544922, 59.84132385253906, 59.826988220214844, 59.766605377197266, 59.87569046020508, 59.853965759277344, 59.80608367919922, 59.820045471191406, 59.89848709106445, 59.84660339355469, 59.808040618896484, 59.83556365966797, 59.817291259765625, 59.78244400024414, 59.84616470336914, 59.85092544555664, 59.88690948486328, 59.90276336669922, 59.89439010620117], "compile_time": 1837.7336920239031, "verification_time": 0, "benchmark_time": 1916.275770869106, "GFLOP/s": 126.17175119707785, "strategy_time": 0, "framework_time": 1.4564511366188526, "timestamp": "2023-12-21 10:49:10.926429+00:00"},
+"16,2,3,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 37.5335590839386, "times": [37.81419372558594, 37.516807556152344, 37.5197868347168, 37.44115447998047, 37.47722625732422, 37.526119232177734, 37.53546905517578, 37.55299377441406, 37.49418640136719, 37.47832107543945, 37.535789489746094, 37.49615478515625, 37.472267150878906, 37.568870544433594, 37.479148864746094, 37.4688720703125, 37.50986862182617, 37.51142120361328, 37.516746520996094, 37.63207244873047, 37.57770919799805, 37.775001525878906, 37.506507873535156, 37.488460540771484, 37.50826644897461, 37.51016616821289, 37.576908111572266, 37.54257583618164, 37.51930618286133, 37.44636917114258, 37.57386779785156, 37.50128173828125], "compile_time": 878.1905346550047, "verification_time": 0, "benchmark_time": 1202.6326642371714, "GFLOP/s": 201.14658413064524, "strategy_time": 0, "framework_time": 1.6151582822203636, "timestamp": "2023-12-21 10:49:13.008883+00:00"},
+"16,2,3,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 42.3323677778244, "times": [42.38832473754883, 42.34145736694336, 42.352962493896484, 42.321468353271484, 42.33040237426758, 42.39102554321289, 42.304805755615234, 42.32931137084961, 42.33696365356445, 42.33345413208008, 42.339683532714844, 42.33660888671875, 42.37552261352539, 42.37714385986328, 42.2708854675293, 42.40011978149414, 42.23104476928711, 42.297733306884766, 42.28224563598633, 42.35700225830078, 42.29632568359375, 42.332279205322266, 42.3876838684082, 42.36302185058594, 42.312965393066406, 42.34355163574219, 42.2904052734375, 42.24076461791992, 42.273765563964844, 42.402381896972656, 42.37904357910156, 42.31541442871094], "compile_time": 860.5518597178161, "verification_time": 0, "benchmark_time": 1356.211684178561, "GFLOP/s": 178.34455279288431, "strategy_time": 0, "framework_time": 1.3660062104463577, "timestamp": "2023-12-21 10:49:15.227030+00:00"},
+"16,2,3,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 63.31035017967224, "times": [58.14002227783203, 64.57268524169922, 63.049835205078125, 55.066226959228516, 67.10069274902344, 61.55254364013672, 68.75505828857422, 55.08702850341797, 61.23918533325195, 66.13967895507812, 62.70822525024414, 63.58292007446289, 67.49573516845703, 63.12791442871094, 53.974056243896484, 63.42787170410156, 65.94467163085938, 64.10962677001953, 60.9555778503418, 58.77635955810547, 61.164215087890625, 67.5533676147461, 68.31800079345703, 62.62259292602539, 66.0086898803711, 63.52316665649414, 67.98245239257812, 64.87330627441406, 68.43608093261719, 64.89421081542969, 58.220985412597656, 67.5282211303711], "compile_time": 2562.0650351047516, "verification_time": 0, "benchmark_time": 2027.4572232738137, "GFLOP/s": 119.24980952678543, "strategy_time": 0, "framework_time": 1.5045437030494213, "timestamp": "2023-12-21 10:49:19.818071+00:00"},
+"16,2,3,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 37.55704700946808, "times": [37.766353607177734, 37.607391357421875, 37.59979248046875, 37.55152130126953, 37.55354690551758, 37.57206344604492, 37.49674987792969, 37.515830993652344, 37.551307678222656, 37.56315231323242, 37.59162902832031, 37.52159118652344, 37.403629302978516, 37.533355712890625, 37.537227630615234, 37.47722625732422, 37.61178970336914, 37.576053619384766, 37.62394714355469, 37.58047866821289, 37.54602813720703, 37.52738571166992, 37.60667037963867, 37.51987075805664, 37.457706451416016, 37.649871826171875, 37.57450866699219, 37.523719787597656, 37.573707580566406, 37.5518684387207, 37.49994659423828, 37.5595817565918], "compile_time": 1194.8945266194642, "verification_time": 0, "benchmark_time": 1203.4824336878955, "GFLOP/s": 201.02078840481573, "strategy_time": 0, "framework_time": 1.4861878007650375, "timestamp": "2023-12-21 10:49:22.217950+00:00"},
+"16,2,3,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.05651783943176, "times": [40.022056579589844, 40.09962463378906, 40.050376892089844, 40.05790328979492, 40.12062072753906, 40.09684753417969, 39.979976654052734, 40.074195861816406, 40.07789611816406, 40.11198425292969, 40.03821563720703, 40.05778503417969, 39.95613479614258, 40.143287658691406, 40.08781433105469, 40.027652740478516, 40.15037536621094, 39.965396881103516, 40.10285568237305, 40.067291259765625, 40.018375396728516, 40.0211181640625, 40.035335540771484, 39.981990814208984, 40.00797653198242, 40.025360107421875, 40.06333541870117, 40.021728515625, 40.03005599975586, 40.07068634033203, 40.1385383605957, 40.105777740478516], "compile_time": 1203.793715685606, "verification_time": 0, "benchmark_time": 1283.4036219865084, "GFLOP/s": 188.47737165430803, "strategy_time": 0, "framework_time": 1.455138437449932, "timestamp": "2023-12-21 10:49:24.706619+00:00"},
+"16,2,3,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 68.67299509048462, "times": [68.6601333618164, 68.6635971069336, 68.64618682861328, 68.65422058105469, 68.6270751953125, 68.6871337890625, 68.71578979492188, 68.86499786376953, 68.59114837646484, 68.66413879394531, 68.58992767333984, 68.7430191040039, 68.66078186035156, 68.6594467163086, 68.73351287841797, 68.64083099365234, 68.65520477294922, 68.58067321777344, 68.6081771850586, 68.71022033691406, 68.67369079589844, 68.71636199951172, 68.71367645263672, 68.69029235839844, 68.72518157958984, 68.63806915283203, 68.72909545898438, 68.67747497558594, 68.64826965332031, 68.73770904541016, 68.64111328125, 68.58869171142578], "compile_time": 3111.602883785963, "verification_time": 0, "benchmark_time": 2199.069426394999, "GFLOP/s": 109.93764273791079, "strategy_time": 0, "framework_time": 1.4358307234942913, "timestamp": "2023-12-21 10:49:30.018742+00:00"},
+"16,2,3,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 36.36144697666168, "times": [36.36537551879883, 36.53860855102539, 36.38041687011719, 36.49639892578125, 36.484256744384766, 36.39410400390625, 36.609214782714844, 36.41889953613281, 36.236576080322266, 36.401275634765625, 36.293216705322266, 36.25762176513672, 36.2808952331543, 36.251983642578125, 36.53577423095703, 36.37590026855469, 36.31353759765625, 36.381778717041016, 36.4600944519043, 36.32053756713867, 36.004573822021484, 36.35803985595703, 36.243934631347656, 36.369686126708984, 36.446014404296875, 36.36589431762695, 36.37113571166992, 36.34724807739258, 36.36329650878906, 36.17670440673828, 36.42745590209961, 36.29585266113281], "compile_time": 1173.4083048067987, "verification_time": 0, "benchmark_time": 1165.1701210066676, "GFLOP/s": 207.63054904953995, "strategy_time": 0, "framework_time": 1.4820513315498829, "timestamp": "2023-12-21 10:49:32.358820+00:00"},
+"16,2,3,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.290565848350525, "times": [40.16333770751953, 40.2901496887207, 40.32318115234375, 40.232112884521484, 40.31101989746094, 40.3354377746582, 40.344139099121094, 40.379310607910156, 40.23181915283203, 40.266143798828125, 40.35805892944336, 40.21791458129883, 40.22734069824219, 40.38509750366211, 40.298858642578125, 40.312774658203125, 40.34973907470703, 40.35731887817383, 40.36045837402344, 40.32542037963867, 40.036617279052734, 40.22911071777344, 40.35710144042969, 40.25864791870117, 40.365421295166016, 40.3596305847168, 40.24654006958008, 40.30147171020508, 40.367820739746094, 40.23237991333008, 40.191341400146484, 40.28239059448242], "compile_time": 1176.6644096933305, "verification_time": 0, "benchmark_time": 1290.742713958025, "GFLOP/s": 187.38250607887858, "strategy_time": 0, "framework_time": 1.5804502181708813, "timestamp": "2023-12-21 10:49:34.827823+00:00"},
+"16,2,3,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 66.65770053863525, "times": [66.65996551513672, 66.69415283203125, 66.6740951538086, 66.63762664794922, 66.68031311035156, 66.69327545166016, 66.69019317626953, 66.66620635986328, 66.6274642944336, 66.68434143066406, 66.59793090820312, 66.65818786621094, 66.70407104492188, 66.65800476074219, 66.75655364990234, 66.62433624267578, 66.6117172241211, 66.66686248779297, 66.72582244873047, 66.61441040039062, 66.60948181152344, 66.65483093261719, 66.69426727294922, 66.58935546875, 66.6288833618164, 66.59104919433594, 66.65137481689453, 66.67615509033203, 66.70948028564453, 66.66215515136719, 66.66217041015625, 66.59168243408203], "compile_time": 1749.6369360014796, "verification_time": 0, "benchmark_time": 2134.807663038373, "GFLOP/s": 113.26144074868164, "strategy_time": 0, "framework_time": 1.447153277695179, "timestamp": "2023-12-21 10:49:38.713739+00:00"},
+"16,2,3,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 24.606234431266785, "times": [24.637720108032227, 24.599159240722656, 24.610782623291016, 24.648122787475586, 24.600439071655273, 24.588138580322266, 24.54475975036621, 24.539960861206055, 24.535776138305664, 24.63772201538086, 24.654361724853516, 24.61161994934082, 24.60972023010254, 24.57900047302246, 24.600238800048828, 24.537559509277344, 24.545879364013672, 24.568464279174805, 24.54987907409668, 24.656919479370117, 24.610187530517578, 24.62299919128418, 24.599000930786133, 24.629619598388672, 24.64348030090332, 24.837404251098633, 24.594024658203125, 24.579320907592773, 24.60219955444336, 24.569759368896484, 24.600439071655273, 24.654842376708984], "compile_time": 848.1001630425453, "verification_time": 0, "benchmark_time": 789.0471760183573, "GFLOP/s": 306.82253398377145, "strategy_time": 0, "framework_time": 1.5021092258393764, "timestamp": "2023-12-21 10:49:40.352404+00:00"},
+"16,2,3,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 25.693598806858063, "times": [25.690372467041016, 25.739173889160156, 25.69803237915039, 25.692453384399414, 25.74173355102539, 25.715547561645508, 25.70909309387207, 25.696134567260742, 25.634918212890625, 25.697574615478516, 25.659971237182617, 25.693593978881836, 25.6890926361084, 25.753894805908203, 25.766815185546875, 25.682052612304688, 25.693571090698242, 25.686851501464844, 25.697572708129883, 25.68973159790039, 25.682899475097656, 25.68781280517578, 25.67565155029297, 25.72390365600586, 25.704132080078125, 25.695812225341797, 25.658723831176758, 25.672611236572266, 25.68317222595215, 25.652555465698242, 25.673734664916992, 25.65597152709961], "compile_time": 855.8772732503712, "verification_time": 0, "benchmark_time": 823.7659502774477, "GFLOP/s": 293.83766971502814, "strategy_time": 0, "framework_time": 1.4745844528079033, "timestamp": "2023-12-21 10:49:42.033538+00:00"},
+"16,2,3,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 66.27214550971985, "times": [66.33541107177734, 66.29659271240234, 66.25504302978516, 66.2992172241211, 66.24517059326172, 66.27778625488281, 66.3355941772461, 66.24896240234375, 66.31498718261719, 66.34111022949219, 66.35626220703125, 66.212646484375, 66.26653289794922, 66.36088562011719, 66.17369842529297, 66.24276733398438, 66.26221466064453, 66.24018859863281, 66.26066589355469, 66.2684097290039, 66.26519775390625, 66.12324523925781, 66.26354217529297, 66.23004913330078, 66.2874984741211, 66.26094055175781, 66.31877899169922, 66.40914916992188, 66.27462768554688, 66.22964477539062, 66.25560760498047, 66.19622802734375], "compile_time": 2193.257240578532, "verification_time": 0, "benchmark_time": 2122.399643994868, "GFLOP/s": 113.92036793033523, "strategy_time": 0, "framework_time": 1.4851861633360386, "timestamp": "2023-12-21 10:49:46.350695+00:00"},
+"16,2,3,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 24.532335221767426, "times": [24.579479217529297, 24.78316307067871, 24.534576416015625, 24.54043960571289, 24.55068016052246, 24.54865264892578, 24.615320205688477, 24.499479293823242, 24.518117904663086, 24.5279598236084, 24.514999389648438, 24.608680725097656, 24.503639221191406, 24.49803924560547, 24.59745216369629, 24.44732093811035, 24.537080764770508, 24.508464813232422, 24.533559799194336, 24.466039657592773, 24.56248664855957, 24.567960739135742, 24.434520721435547, 24.551786422729492, 24.435800552368164, 24.56875991821289, 24.56507110595703, 24.484119415283203, 24.455320358276367, 24.538076400756836, 24.496280670166016, 24.46139907836914], "compile_time": 845.1336077414453, "verification_time": 0, "benchmark_time": 786.5989748388529, "GFLOP/s": 307.746781207406, "strategy_time": 0, "framework_time": 1.619507558643818, "timestamp": "2023-12-21 10:49:47.984064+00:00"},
+"16,2,3,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 25.256840646266937, "times": [25.30620765686035, 25.31996726989746, 25.259998321533203, 25.22844886779785, 25.268447875976562, 25.326669692993164, 25.304607391357422, 25.273887634277344, 25.272218704223633, 25.2271671295166, 25.2457275390625, 25.231460571289062, 25.269407272338867, 25.270048141479492, 25.250320434570312, 25.24844741821289, 25.2225284576416, 25.243425369262695, 25.25836753845215, 25.269887924194336, 25.274587631225586, 25.271808624267578, 25.255647659301758, 25.24557876586914, 25.223007202148438, 25.218847274780273, 25.268272399902344, 25.201568603515625, 25.251808166503906, 25.22547721862793, 25.28348731994629, 25.201568603515625], "compile_time": 852.9073819518089, "verification_time": 0, "benchmark_time": 809.682936873287, "GFLOP/s": 298.9189069898924, "strategy_time": 0, "framework_time": 1.526357140392065, "timestamp": "2023-12-21 10:49:49.648197+00:00"},
+"16,2,4,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.636387929320335, "times": [7.661046981811523, 7.633687973022461, 7.628246784210205, 7.6322479248046875, 7.627767086029053, 7.635127067565918, 7.624406814575195, 7.6296868324279785, 7.6301589012146, 7.626327037811279, 7.839448928833008, 7.638007164001465, 7.635927200317383, 7.626486778259277, 7.6317667961120605, 7.625687122344971, 7.621686935424805, 7.62847900390625, 7.628246784210205, 7.628727912902832, 7.6276068687438965, 7.624086856842041, 7.627127170562744, 7.627447128295898, 7.627447128295898, 7.62472677230835, 7.633807182312012, 7.623287200927734, 7.628888130187988, 7.627447128295898, 7.628567218780518, 7.630806922912598], "compile_time": 2958.2955529913306, "verification_time": 0, "benchmark_time": 245.7888820208609, "GFLOP/s": 988.6542263014593, "strategy_time": 0, "framework_time": 1.305358950048685, "timestamp": "2023-12-21 10:49:52.853602+00:00"},
+"16,2,4,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.973365545272827, "times": [10.014993667602539, 9.976273536682129, 9.976914405822754, 9.972753524780273, 9.972594261169434, 9.970193862915039, 9.974266052246094, 9.972753524780273, 9.973553657531738, 9.97115421295166, 9.966193199157715, 9.970354080200195, 9.980274200439453, 9.968257904052734, 9.97115421295166, 9.969074249267578, 9.973393440246582, 9.977073669433594, 9.973394393920898, 9.972273826599121, 9.971680641174316, 9.97115421295166, 9.970033645629883, 9.973234176635742, 9.972594261169434, 9.970833778381348, 9.971954345703125, 9.971742630004883, 9.96843433380127, 9.969234466552734, 9.967473983764648, 9.972433090209961], "compile_time": 648.8115699030459, "verification_time": 0, "benchmark_time": 320.74538618326187, "GFLOP/s": 756.9909240495479, "strategy_time": 0, "framework_time": 1.3662348501384258, "timestamp": "2023-12-21 10:49:53.824540+00:00"},
+"16,2,4,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.897019654512405, "times": [9.919952392578125, 9.890192985534668, 9.88955307006836, 9.890993118286133, 9.9015531539917, 9.889232635498047, 9.889898300170898, 9.890032768249512, 9.889713287353516, 9.886993408203125, 9.887792587280273, 9.886833190917969, 9.893233299255371, 9.891189575195312, 9.88955307006836, 9.890671730041504, 9.887792587280273, 9.886512756347656, 9.889073371887207, 10.093555450439453, 9.888525009155273, 9.885872840881348, 9.88347339630127, 9.888113021850586, 9.889713287353516, 9.886833190917969, 9.896272659301758, 9.889129638671875, 9.889073371887207, 9.886833190917969, 9.896753311157227, 9.889713287353516], "compile_time": 651.2399106286466, "verification_time": 0, "benchmark_time": 318.2028718292713, "GFLOP/s": 762.8303735415741, "strategy_time": 0, "framework_time": 1.4735045842826366, "timestamp": "2023-12-21 10:49:54.795471+00:00"},
+"16,2,4,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.2954658791422844, "times": [3.328356981277466, 3.2973179817199707, 3.29571795463562, 3.2920379638671875, 3.2937979698181152, 3.2934770584106445, 3.2987570762634277, 3.2952370643615723, 3.292836904525757, 3.2950780391693115, 3.297797918319702, 3.292678117752075, 3.293956995010376, 3.293956995010376, 3.2952380180358887, 3.296678066253662, 3.2929980754852295, 3.2950780391693115, 3.293903112411499, 3.2912371158599854, 3.291717052459717, 3.293478012084961, 3.2920379638671875, 3.293478012084961, 3.294437885284424, 3.292517900466919, 3.2937979698181152, 3.2934770584106445, 3.3014779090881348, 3.2942769527435303, 3.2925169467926025, 3.2955570220947266], "compile_time": 673.623648006469, "verification_time": 0, "benchmark_time": 106.90499329939485, "GFLOP/s": 2290.949892027097, "strategy_time": 0, "framework_time": 1.3860235922038555, "timestamp": "2023-12-21 10:49:55.577401+00:00"},
+"16,2,4,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.97251182794571, "times": [10.000593185424805, 9.96955394744873, 9.966354370117188, 9.968753814697266, 9.967473983764648, 9.964914321899414, 9.971687316894531, 9.970193862915039, 9.96955394744873, 9.96251392364502, 9.962353706359863, 9.96411418914795, 9.962512969970703, 9.96416187286377, 9.964754104614258, 9.971794128417969, 9.961073875427246, 9.959953308105469, 9.961713790893555, 9.966513633728027, 9.967172622680664, 9.964754104614258, 9.962352752685547, 9.964914321899414, 9.966193199157715, 9.964433670043945, 9.966354370117188, 9.969529151916504, 10.157236099243164, 9.964593887329102, 9.962512969970703, 9.959793090820312], "compile_time": 647.5240350700915, "verification_time": 0, "benchmark_time": 320.64100401476026, "GFLOP/s": 757.055727810073, "strategy_time": 0, "framework_time": 1.2936959974467754, "timestamp": "2023-12-21 10:49:56.546874+00:00"},
+"16,2,4,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.88398340344429, "times": [9.909872055053711, 9.891312599182129, 9.88187313079834, 9.882033348083496, 9.887473106384277, 9.882033348083496, 9.882457733154297, 9.881393432617188, 9.884272575378418, 9.885553359985352, 9.881552696228027, 9.881712913513184, 9.883152961730957, 9.87689208984375, 9.883953094482422, 9.885553359985352, 9.8829927444458, 9.884432792663574, 9.880593299865723, 9.881393432617188, 9.884147644042969, 9.87915325164795, 9.883152961730957, 9.879793167114258, 9.884753227233887, 9.896753311157227, 9.886033058166504, 9.881125450134277, 9.880433082580566, 9.881072998046875, 9.879953384399414, 9.880593299865723], "compile_time": 643.6552829109132, "verification_time": 0, "benchmark_time": 317.94249918311834, "GFLOP/s": 763.8364910011003, "strategy_time": 0, "framework_time": 1.444938126951456, "timestamp": "2023-12-21 10:49:57.509932+00:00"},
+"16,2,4,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.491895824670792, "times": [10.835963249206543, 10.491318702697754, 10.483480453491211, 10.483960151672363, 10.480759620666504, 10.491517066955566, 10.481399536132812, 10.48523998260498, 10.469079971313477, 10.475958824157715, 10.471799850463867, 10.489903450012207, 10.47484016418457, 10.501239776611328, 10.492440223693848, 10.483320236206055, 10.475319862365723, 10.493602752685547, 10.47083854675293, 10.476920127868652, 10.469079971313477, 10.469719886779785, 10.479960441589355, 10.484651565551758, 10.481398582458496, 10.497400283813477, 10.477239608764648, 10.481879234313965, 10.474519729614258, 10.48159408569336, 10.469400405883789, 10.464920043945312], "compile_time": 2619.157820008695, "verification_time": 0, "benchmark_time": 337.54492923617363, "GFLOP/s": 719.5789327461123, "strategy_time": 0, "framework_time": 1.3510971330106258, "timestamp": "2023-12-21 10:50:00.468001+00:00"},
+"16,2,4,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.752732574939728, "times": [5.790625095367432, 5.750946044921875, 5.749505043029785, 5.745824813842773, 5.7453460693359375, 5.969828128814697, 5.745665073394775, 5.742465019226074, 5.741025924682617, 5.744545936584473, 5.741971015930176, 5.742304801940918, 5.742946147918701, 5.7455058097839355, 5.747584819793701, 5.74870491027832, 5.744545936584473, 5.7432661056518555, 5.744386196136475, 5.741984844207764, 5.74198579788208, 5.741581916809082, 5.741665840148926, 5.74198579788208, 5.749505996704102, 5.749986171722412, 5.741186141967773, 5.740065097808838, 5.741344928741455, 5.743105888366699, 5.742306232452393, 5.743744850158691], "compile_time": 969.7988433763385, "verification_time": 0, "benchmark_time": 185.87850499898195, "GFLOP/s": 1312.3758321199382, "strategy_time": 0, "framework_time": 1.3710148632526398, "timestamp": "2023-12-21 10:50:01.625066+00:00"},
+"16,2,4,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.705245345830917, "times": [5.738464832305908, 5.7119059562683105, 5.712864875793457, 5.706786155700684, 5.70342493057251, 5.698945999145508, 5.7051849365234375, 5.713345050811768, 5.702145099639893, 5.703744888305664, 5.702812194824219, 5.706785202026367, 5.705665111541748, 5.70342493057251, 5.701505184173584, 5.704705238342285, 5.702145099639893, 5.703425884246826, 5.702945232391357, 5.700864791870117, 5.702785015106201, 5.709643840789795, 5.702304840087891, 5.701825141906738, 5.6995849609375, 5.702145099639893, 5.699904918670654, 5.7037458419799805, 5.6995849609375, 5.704864978790283, 5.701025009155273, 5.709344863891602], "compile_time": 979.2795339599252, "verification_time": 0, "benchmark_time": 183.9748090133071, "GFLOP/s": 1323.2993048260307, "strategy_time": 0, "framework_time": 1.3528792187571526, "timestamp": "2023-12-21 10:50:02.789690+00:00"},
+"16,2,4,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.9484561085700989, "times": [1.9752219915390015, 1.9478620290756226, 1.9425820112228394, 1.9419430494308472, 1.9400219917297363, 1.941301941871643, 1.942262053489685, 1.9430619478225708, 1.9395420551300049, 1.9430630207061768, 1.9405020475387573, 1.9389020204544067, 1.9390619993209839, 1.9389020204544067, 2.1518640518188477, 1.9449820518493652, 1.9405020475387573, 1.941303014755249, 1.9405020475387573, 1.9409819841384888, 1.937142014503479, 1.9384219646453857, 1.938581943511963, 1.9382630586624146, 1.9435420036315918, 1.941622018814087, 1.9406620264053345, 1.9414620399475098, 1.9373019933700562, 1.9400219917297363, 1.939702033996582, 1.939507007598877], "compile_time": 975.5166061222553, "verification_time": 0, "benchmark_time": 64.34569600969553, "GFLOP/s": 3874.7330087617343, "strategy_time": 0, "framework_time": 1.356756780296564, "timestamp": "2023-12-21 10:50:03.830926+00:00"},
+"16,2,4,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.741777345538139, "times": [5.773825168609619, 5.7463059425354, 5.742785930633545, 5.7407050132751465, 5.741344928741455, 5.73974609375, 5.739426136016846, 5.74198579788208, 5.739745140075684, 5.739105224609375, 5.739674091339111, 5.741826057434082, 5.737346172332764, 5.7386250495910645, 5.740385055541992, 5.7413458824157715, 5.741186141967773, 5.738945007324219, 5.7453460693359375, 5.743105888366699, 5.74406623840332, 5.738591194152832, 5.739106178283691, 5.739585876464844, 5.739745140075684, 5.739745140075684, 5.742946147918701, 5.738626003265381, 5.739425182342529, 5.740065097808838, 5.740705966949463, 5.741506099700928], "compile_time": 975.0398332253098, "verification_time": 0, "benchmark_time": 185.727683827281, "GFLOP/s": 1314.879826516925, "strategy_time": 0, "framework_time": 1.3551339507102966, "timestamp": "2023-12-21 10:50:04.993065+00:00"},
+"16,2,4,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.707334384322166, "times": [5.739904880523682, 5.708546161651611, 5.705345153808594, 5.704706192016602, 5.698305130004883, 5.701344966888428, 5.697824954986572, 5.701826095581055, 5.6959052085876465, 5.699106216430664, 5.696242809295654, 5.704864978790283, 5.701825141906738, 5.693665027618408, 5.6960649490356445, 5.695106029510498, 5.6991047859191895, 5.697344779968262, 5.6959052085876465, 5.696865081787109, 5.694145202636719, 5.696018218994141, 5.695584774017334, 5.934308052062988, 5.699745178222656, 5.696225166320801, 5.69526481628418, 5.696545124053955, 5.698625087738037, 5.6960649490356445, 5.7072649002075195, 5.695105075836182], "compile_time": 972.5595996715128, "verification_time": 0, "benchmark_time": 183.98412596434355, "GFLOP/s": 1322.8149415493986, "strategy_time": 0, "framework_time": 1.4508701860904694, "timestamp": "2023-12-21 10:50:06.151075+00:00"},
+"16,2,4,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 71.8893301486969, "times": [72.28685760498047, 71.84014129638672, 72.06929779052734, 72.00833892822266, 71.82086944580078, 71.83171081542969, 71.87948608398438, 71.89339447021484, 71.7161636352539, 71.84024047851562, 72.11968231201172, 71.82954406738281, 71.72843170166016, 71.94219970703125, 71.81930541992188, 71.84123992919922, 71.79459381103516, 71.72294616699219, 71.71134185791016, 71.84523010253906, 72.01337432861328, 71.73419952392578, 71.87842559814453, 71.86761474609375, 71.75883483886719, 72.06831359863281, 72.01014709472656, 72.02964782714844, 72.0509033203125, 71.85635375976562, 71.73550415039062, 71.91423034667969], "compile_time": 3354.1791760362685, "verification_time": 0, "benchmark_time": 2302.0193190313876, "GFLOP/s": 105.01902277269792, "strategy_time": 0, "framework_time": 1.3909032568335533, "timestamp": "2023-12-21 10:50:11.808681+00:00"},
+"16,2,4,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.695662260055542, "times": [15.758419036865234, 15.70353889465332, 15.709620475769043, 15.682405471801758, 15.692178726196289, 15.682579040527344, 15.68001937866211, 15.715160369873047, 15.706098556518555, 15.697139739990234, 15.661458969116211, 15.662721633911133, 15.684659004211426, 15.728500366210938, 15.717459678649902, 15.711382865905762, 15.696019172668457, 15.667058944702148, 15.715860366821289, 15.69653034210205, 15.685619354248047, 15.698260307312012, 15.716339111328125, 15.68625259399414, 15.673938751220703, 15.707219123840332, 15.670578956604004, 15.704085350036621, 15.690098762512207, 15.695059776306152, 15.701139450073242, 15.663789749145508], "compile_time": 869.8228793218732, "verification_time": 0, "benchmark_time": 503.7519899196923, "GFLOP/s": 481.0085152770918, "strategy_time": 0, "framework_time": 1.4790836721658707, "timestamp": "2023-12-21 10:50:13.183752+00:00"},
+"16,2,4,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.71804291009903, "times": [16.037302017211914, 15.750100135803223, 15.750740051269531, 15.760234832763672, 15.677779197692871, 15.697778701782227, 15.721779823303223, 15.667537689208984, 15.705619812011719, 15.726899147033691, 15.709939956665039, 15.686984062194824, 15.685938835144043, 15.656018257141113, 15.715218544006348, 15.707809448242188, 15.712339401245117, 15.697299003601074, 15.721139907836914, 15.701783180236816, 15.716178894042969, 15.755059242248535, 15.726900100708008, 15.710268020629883, 15.703859329223633, 15.681300163269043, 15.687699317932129, 15.71592903137207, 15.688179016113281, 15.693778991699219, 15.706098556518555, 15.70188045501709], "compile_time": 869.689981918782, "verification_time": 0, "benchmark_time": 504.4909310527146, "GFLOP/s": 480.3236155532568, "strategy_time": 0, "framework_time": 1.3966350816190243, "timestamp": "2023-12-21 10:50:14.559345+00:00"},
+"16,2,4,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 71.60994625091553, "times": [74.64942169189453, 73.49970245361328, 71.43907928466797, 71.35028076171875, 71.36571502685547, 71.477294921875, 71.53462982177734, 71.3154296875, 71.72000122070312, 71.6326904296875, 71.31665802001953, 71.49907684326172, 71.48811340332031, 71.3627700805664, 71.44679260253906, 71.2841567993164, 71.52299499511719, 71.45114135742188, 71.46776580810547, 71.54314422607422, 71.23020935058594, 71.51019287109375, 71.38233947753906, 71.56060791015625, 71.41166687011719, 71.4141845703125, 71.60346221923828, 71.33844757080078, 71.3615951538086, 71.45417785644531, 71.40494537353516, 71.4795913696289], "compile_time": 4350.380748976022, "verification_time": 0, "benchmark_time": 2293.0727140046656, "GFLOP/s": 105.4287511059747, "strategy_time": 0, "framework_time": 1.3904119841754436, "timestamp": "2023-12-21 10:50:21.204204+00:00"},
+"16,2,4,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.667645931243896, "times": [15.735539436340332, 15.730098724365234, 15.648979187011719, 15.675146102905273, 15.698099136352539, 15.628978729248047, 15.655538558959961, 15.673271179199219, 15.665139198303223, 15.852980613708496, 15.662899017333984, 15.65126895904541, 15.656659126281738, 15.675378799438477, 15.65457820892334, 15.647354125976562, 15.663859367370605, 15.661138534545898, 15.664978981018066, 15.656490325927734, 15.648017883300781, 15.644179344177246, 15.666739463806152, 15.642049789428711, 15.675378799438477, 15.645298957824707, 15.64401912689209, 15.638014793395996, 15.657137870788574, 15.636658668518066, 15.655219078063965, 15.653579711914062], "compile_time": 868.7428580597043, "verification_time": 0, "benchmark_time": 502.9649347998202, "GFLOP/s": 481.86863764546445, "strategy_time": 0, "framework_time": 1.6034548170864582, "timestamp": "2023-12-21 10:50:22.577533+00:00"},
+"16,2,4,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.689793080091476, "times": [15.755538940429688, 15.73345947265625, 15.69489860534668, 15.689908981323242, 15.677139282226562, 15.699379920959473, 15.672658920288086, 15.703346252441406, 15.689779281616211, 15.67953872680664, 15.67841911315918, 15.69677734375, 15.694258689880371, 15.680659294128418, 15.654898643493652, 15.70959186553955, 15.725138664245605, 15.687378883361816, 15.7110595703125, 15.660615921020508, 15.693618774414062, 15.658577919006348, 15.682899475097656, 15.688488006591797, 15.673778533935547, 15.682258605957031, 15.664178848266602, 15.694528579711914, 15.686578750610352, 15.667698860168457, 15.686899185180664, 15.699426651000977], "compile_time": 870.7178933545947, "verification_time": 0, "benchmark_time": 503.49027337506413, "GFLOP/s": 481.1884491695274, "strategy_time": 0, "framework_time": 1.2439079582691193, "timestamp": "2023-12-21 10:50:23.953000+00:00"},
+"16,2,4,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.71118201315403, "times": [6.743276119232178, 6.70423698425293, 6.712396144866943, 6.697996139526367, 6.699595928192139, 6.69223690032959, 6.699596881866455, 6.709677219390869, 6.704876899719238, 6.7011799812316895, 6.704875946044922, 6.709035873413086, 6.706955909729004, 6.707756996154785, 6.697835922241211, 6.712555885314941, 6.694955825805664, 6.701035976409912, 6.9197587966918945, 6.717030048370361, 6.70471715927124, 6.705836772918701, 6.705357074737549, 6.710637092590332, 6.703436851501465, 6.696396827697754, 6.701676845550537, 6.705356121063232, 6.696556091308594, 6.697235107421875, 6.6963958740234375, 6.697356224060059], "compile_time": 1807.9926907084882, "verification_time": 0, "benchmark_time": 216.05178760364652, "GFLOP/s": 1124.95044616617, "strategy_time": 0, "framework_time": 1.4208713546395302, "timestamp": "2023-12-21 10:50:25.978481+00:00"},
+"16,2,4,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 14.442193388938904, "times": [14.56832504272461, 14.475045204162598, 14.54672622680664, 14.387364387512207, 14.467647552490234, 14.414565086364746, 14.464005470275879, 14.437925338745117, 14.41760540008545, 14.466666221618652, 14.43248462677002, 14.40064525604248, 14.424164772033691, 14.433764457702637, 14.428808212280273, 14.465764999389648, 14.372644424438477, 14.439845085144043, 14.43344497680664, 14.462573051452637, 14.465285301208496, 14.405444145202637, 14.447364807128906, 14.40096378326416, 14.411075592041016, 14.476964950561523, 14.434564590454102, 14.443204879760742, 14.468484878540039, 14.41041088104248, 14.441604614257812, 14.404804229736328], "compile_time": 1259.0838032774627, "verification_time": 0, "benchmark_time": 463.71066477149725, "GFLOP/s": 522.7562736960895, "strategy_time": 0, "framework_time": 1.4448179863393307, "timestamp": "2023-12-21 10:50:27.702736+00:00"},
+"16,2,4,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 14.12120708823204, "times": [14.256321907043457, 14.173602104187012, 14.166082382202148, 14.1264009475708, 14.131239891052246, 14.167362213134766, 14.122241973876953, 14.108321189880371, 14.115200996398926, 14.110071182250977, 14.049440383911133, 14.150721549987793, 14.121601104736328, 14.092161178588867, 14.091529846191406, 14.112001419067383, 14.077601432800293, 14.083200454711914, 14.110401153564453, 14.09117317199707, 14.117441177368164, 14.074240684509277, 14.11648178100586, 14.144001960754395, 14.091850280761719, 14.120161056518555, 14.080801010131836, 14.32064437866211, 14.067840576171875, 14.082405090332031, 14.094881057739258, 14.111201286315918], "compile_time": 1249.8257039114833, "verification_time": 0, "benchmark_time": 453.3209837973118, "GFLOP/s": 534.6389407667288, "strategy_time": 0, "framework_time": 1.247386448085308, "timestamp": "2023-12-21 10:50:29.407144+00:00"},
+"16,2,4,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.881130322813988, "times": [7.039120197296143, 6.882958889007568, 6.860558032989502, 6.888718128204346, 6.87271785736084, 6.881678104400635, 6.867279052734375, 6.852397918701172, 6.88887882232666, 6.895153999328613, 6.857838153839111, 6.871918201446533, 6.876079082489014, 6.905519008636475, 6.893679141998291, 6.908557891845703, 6.868718147277832, 6.86663818359375, 6.876718044281006, 6.866905212402344, 6.880719184875488, 6.875759124755859, 6.853999137878418, 6.901678085327148, 6.863758087158203, 6.856557846069336, 6.848718166351318, 6.86887788772583, 6.8794379234313965, 6.885115146636963, 6.874478816986084, 6.88503885269165], "compile_time": 1423.2248519547284, "verification_time": 0, "benchmark_time": 221.88510512933135, "GFLOP/s": 1097.16672200921, "strategy_time": 0, "framework_time": 1.3292739167809486, "timestamp": "2023-12-21 10:50:31.053599+00:00"},
+"16,2,4,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 14.544021338224411, "times": [14.632966041564941, 14.628486633300781, 14.58560562133789, 14.545926094055176, 14.533909797668457, 14.533926010131836, 14.576005935668945, 14.564166069030762, 14.53968620300293, 14.542625427246094, 14.520806312561035, 14.511205673217773, 14.513445854187012, 14.523526191711426, 14.544268608093262, 14.530726432800293, 14.514725685119629, 14.537446022033691, 14.53216552734375, 14.557804107666016, 14.527206420898438, 14.573286056518555, 14.532806396484375, 14.5216064453125, 14.535277366638184, 14.54416561126709, 14.518725395202637, 14.525925636291504, 14.524005889892578, 14.54232120513916, 14.550725936889648, 14.543206214904785], "compile_time": 1258.8355420157313, "verification_time": 0, "benchmark_time": 467.12283324450254, "GFLOP/s": 519.0962681110657, "strategy_time": 0, "framework_time": 1.42713263630867, "timestamp": "2023-12-21 10:50:32.781000+00:00"},
+"16,2,4,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 2, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 14.374769181013107, "times": [14.45936393737793, 14.406244277954102, 14.3563232421875, 14.582566261291504, 14.35478687286377, 14.364644050598145, 14.362724304199219, 14.387524604797363, 14.34848403930664, 14.359136581420898, 14.36496353149414, 14.385765075683594, 14.35008430480957, 14.356803894042969, 14.353072166442871, 14.309443473815918, 14.36384391784668, 14.380483627319336, 14.353283882141113, 14.405046463012695, 14.346243858337402, 14.366724014282227, 14.32960319519043, 14.394564628601074, 14.371335983276367, 14.3432035446167, 14.38880443572998, 14.367363929748535, 14.39216423034668, 14.355368614196777, 14.35616397857666, 14.376484870910645], "compile_time": 1252.2315634414554, "verification_time": 0, "benchmark_time": 461.5758000873029, "GFLOP/s": 525.2082384718964, "strategy_time": 0, "framework_time": 1.2552617117762566, "timestamp": "2023-12-21 10:50:34.496078+00:00"},
+"16,4,1,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.691906400024891, "times": [3.7179620265960693, 3.693803071975708, 3.695401906967163, 3.6926820278167725, 3.6918818950653076, 3.690282106399536, 3.6854820251464844, 3.6856420040130615, 3.6907620429992676, 3.685642957687378, 3.6930019855499268, 3.693161964416504, 3.6899619102478027, 3.6930019855499268, 3.6902830600738525, 3.6909220218658447, 3.6857779026031494, 3.6875619888305664, 3.6936419010162354, 3.695241928100586, 3.689321994781494, 3.6946020126342773, 3.696362018585205, 3.6880431175231934, 3.686922073364258, 3.6885221004486084, 3.688041925430298, 3.6909220218658447, 3.692842960357666, 3.6955618858337402, 3.6955618858337402, 3.692202091217041], "compile_time": 659.8223862238228, "verification_time": 0, "benchmark_time": 119.61932992562652, "GFLOP/s": 2044.9454514743654, "strategy_time": 0, "framework_time": 1.3335729017853737, "timestamp": "2023-12-21 10:50:35.276868+00:00"},
+"16,4,1,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.857566088438034, "times": [9.873711585998535, 9.852593421936035, 9.84875202178955, 9.84763240814209, 9.846672058105469, 9.847472190856934, 9.849540710449219, 9.853551864624023, 9.846993446350098, 9.85547161102295, 9.850031852722168, 9.852912902832031, 10.05643367767334, 9.849791526794434, 9.852432250976562, 9.852752685546875, 9.84763240814209, 9.851472854614258, 9.854673385620117, 9.863792419433594, 9.854151725769043, 9.852592468261719, 9.849072456359863, 9.84603214263916, 9.851311683654785, 9.848272323608398, 9.84763240814209, 9.847563743591309, 9.848112106323242, 9.84779167175293, 9.845552444458008, 9.849712371826172], "compile_time": 329.74916975945234, "verification_time": 0, "benchmark_time": 316.6144439019263, "GFLOP/s": 765.883498245588, "strategy_time": 0, "framework_time": 1.289517618715763, "timestamp": "2023-12-21 10:50:35.924537+00:00"},
+"16,4,1,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.818298012018204, "times": [9.846511840820312, 9.8250732421875, 9.826031684875488, 9.82251262664795, 9.818191528320312, 9.816911697387695, 9.818592071533203, 9.821552276611328, 9.813072204589844, 9.81595230102539, 9.821552276611328, 9.81755256652832, 9.817392349243164, 9.81302547454834, 9.817551612854004, 9.82107162475586, 9.815792083740234, 9.815631866455078, 9.813072204589844, 9.81611156463623, 9.81700611114502, 9.81771183013916, 9.816911697387695, 9.815792083740234, 9.817232131958008, 9.817551612854004, 9.815792083740234, 9.81441593170166, 9.817071914672852, 9.814352035522461, 9.81339168548584, 9.815152168273926], "compile_time": 330.3237329237163, "verification_time": 0, "benchmark_time": 315.850913990289, "GFLOP/s": 768.9466331902579, "strategy_time": 0, "framework_time": 1.3340730220079422, "timestamp": "2023-12-21 10:50:36.572061+00:00"},
+"16,4,1,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.8006055019795895, "times": [1.8297799825668335, 1.8025799989700317, 1.7947410345077515, 1.7934609651565552, 1.798740029335022, 1.788661003112793, 1.7976200580596924, 1.7953799962997437, 1.7950609922409058, 1.7897809743881226, 1.7960200309753418, 1.795220971107483, 1.7947399616241455, 1.7931400537490845, 1.7944209575653076, 1.791700005531311, 1.7913800477981567, 1.7859410047531128, 1.7854609489440918, 1.7918610572814941, 1.7918599843978882, 1.988502025604248, 1.795861005783081, 1.7990599870681763, 1.7917009592056274, 1.793619990348816, 1.7944200038909912, 1.7904200553894043, 1.7899409532546997, 1.7928199768066406, 1.7918610572814941, 1.793619990348816], "compile_time": 348.93575590103865, "verification_time": 0, "benchmark_time": 59.63466688990593, "GFLOP/s": 4192.893552585389, "strategy_time": 0, "framework_time": 1.2064352631568909, "timestamp": "2023-12-21 10:50:36.981852+00:00"},
+"16,4,1,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.847984850406647, "times": [9.87707233428955, 9.852911949157715, 9.84443187713623, 9.847311973571777, 9.846193313598633, 9.842512130737305, 9.842639923095703, 9.85531234741211, 9.845232963562012, 9.839153289794922, 9.845552444458008, 9.846672058105469, 9.84907341003418, 9.851361274719238, 9.85035228729248, 9.84907341003418, 9.847792625427246, 9.842673301696777, 9.84011173248291, 9.840592384338379, 9.842914581298828, 9.848592758178711, 9.84923267364502, 9.850993156433105, 9.851792335510254, 9.851312637329102, 9.849712371826172, 9.84776782989502, 9.845871925354004, 9.847152709960938, 9.847792625427246, 9.846352577209473], "compile_time": 324.92060912773013, "verification_time": 0, "benchmark_time": 316.3787270896137, "GFLOP/s": 766.6286366888809, "strategy_time": 0, "framework_time": 1.2461328878998756, "timestamp": "2023-12-21 10:50:37.624413+00:00"},
+"16,4,1,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.821392983198166, "times": [9.844112396240234, 9.816593170166016, 9.81499195098877, 9.81499195098877, 9.813872337341309, 9.813712120056152, 9.817641258239746, 9.816911697387695, 9.81003189086914, 9.814191818237305, 9.816911697387695, 9.81755256652832, 9.815471649169922, 9.813981056213379, 9.814831733703613, 9.810511589050293, 9.81339168548584, 9.817232131958008, 9.816271781921387, 9.812111854553223, 9.812897682189941, 9.815152168273926, 9.81771183013916, 9.81339168548584, 9.80907154083252, 9.813232421875, 9.811311721801758, 9.815478324890137, 9.813872337341309, 9.814831733703613, 10.003793716430664, 9.818511962890625], "compile_time": 325.3296809270978, "verification_time": 0, "benchmark_time": 316.0169869661331, "GFLOP/s": 768.7043185132336, "strategy_time": 0, "framework_time": 1.2943968176841736, "timestamp": "2023-12-21 10:50:38.267069+00:00"},
+"16,4,1,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.1777933426201344, "times": [1.2132929563522339, 1.1841729879379272, 1.1772940158843994, 1.1745740175247192, 1.179373025894165, 1.1739330291748047, 1.1782530546188354, 1.1864140033721924, 1.17473304271698, 1.1790540218353271, 1.1777739524841309, 1.1806529760360718, 1.1729730367660522, 1.1756939888000488, 1.1816129684448242, 1.1739330291748047, 1.1720130443572998, 1.171854019165039, 1.174252986907959, 1.1745729446411133, 1.172333002090454, 1.1766530275344849, 1.1740939617156982, 1.1755330562591553, 1.1785730123519897, 1.1736129522323608, 1.1792140007019043, 1.1715329885482788, 1.1761729717254639, 1.1795339584350586, 1.178892970085144, 1.1768139600753784], "compile_time": 445.87033521384, "verification_time": 0, "benchmark_time": 38.835597690194845, "GFLOP/s": 6410.078005029926, "strategy_time": 0, "framework_time": 1.2777340598404408, "timestamp": "2023-12-21 10:50:38.753068+00:00"},
+"16,4,1,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.147120863199234, "times": [6.179910182952881, 6.1538310050964355, 6.146790981292725, 6.151430130004883, 6.146790981292725, 6.153830051422119, 6.146470069885254, 6.146790027618408, 6.145669937133789, 6.145989894866943, 6.14488410949707, 6.1451897621154785, 6.14454984664917, 6.143750190734863, 6.147270202636719, 6.147590160369873, 6.144390106201172, 6.1461501121521, 6.1451897621154785, 6.143909931182861, 6.144229888916016, 6.14408016204834, 6.14454984664917, 6.142469882965088, 6.143270015716553, 6.144869804382324, 6.146629810333252, 6.1451897621154785, 6.1456708908081055, 6.143270015716553, 6.1490302085876465, 6.144229888916016], "compile_time": 386.781576089561, "verification_time": 0, "benchmark_time": 198.4908999875188, "GFLOP/s": 1228.17614424955, "strategy_time": 0, "framework_time": 1.246203202754259, "timestamp": "2023-12-21 10:50:39.339602+00:00"},
+"16,4,1,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.135094329714775, "times": [6.157989025115967, 6.133510112762451, 6.128870010375977, 6.131750106811523, 6.126150131225586, 6.1298298835754395, 6.125189781188965, 6.343112945556641, 6.129189968109131, 6.127429962158203, 6.129464149475098, 6.123589992523193, 6.128870010375977, 6.124549865722656, 6.126309871673584, 6.121990203857422, 6.13415002822876, 6.123589992523193, 6.123748779296875, 6.124549865722656, 6.139430046081543, 6.124573230743408, 6.125349998474121, 6.123909950256348, 6.12598991394043, 6.1307902336120605, 6.125030040740967, 6.129350185394287, 6.124229907989502, 6.127429962158203, 6.127270221710205, 6.125830173492432], "compile_time": 387.2340717352927, "verification_time": 0, "benchmark_time": 197.84186221659184, "GFLOP/s": 1230.583719541765, "strategy_time": 0, "framework_time": 1.304307021200657, "timestamp": "2023-12-21 10:50:39.925997+00:00"},
+"16,4,1,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.180213537067175, "times": [1.213932991027832, 1.186413049697876, 1.179213047027588, 1.1784130334854126, 1.1745729446411133, 1.1803339719772339, 1.1806540489196777, 1.1784130334854126, 1.1793739795684814, 1.1838539838790894, 1.1790529489517212, 1.1812939643859863, 1.1808140277862549, 1.178413987159729, 1.1782530546188354, 1.1785739660263062, 1.175853967666626, 1.1784130334854126, 1.1796940565109253, 1.175853967666626, 1.1776130199432373, 1.182893991470337, 1.1768139600753784, 1.1809730529785156, 1.1779340505599976, 1.179373025894165, 1.176332950592041, 1.1782530546188354, 1.178413987159729, 1.1782540082931519, 1.1801730394363403, 1.178413987159729], "compile_time": 426.006818190217, "verification_time": 0, "benchmark_time": 38.64465793594718, "GFLOP/s": 6396.93323528646, "strategy_time": 0, "framework_time": 1.1336160823702812, "timestamp": "2023-12-21 10:50:40.391797+00:00"},
+"16,4,1,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.1508131474256516, "times": [6.174630165100098, 6.1451897621154785, 6.144070148468018, 6.1419901847839355, 6.147270202636719, 6.144071102142334, 6.143750190734863, 6.1450300216674805, 6.142789840698242, 6.1419901847839355, 6.143518924713135, 6.144070148468018, 6.144229888916016, 6.142469882965088, 6.141991138458252, 6.142469882965088, 6.352392196655273, 6.1419901847839355, 6.142630100250244, 6.144871234893799, 6.142630100250244, 6.142952919006348, 6.150310039520264, 6.143750190734863, 6.143589973449707, 6.14231014251709, 6.139750957489014, 6.142469882965088, 6.1419901847839355, 6.14070987701416, 6.142470836639404, 6.141670227050781], "compile_time": 385.26473892852664, "verification_time": 0, "benchmark_time": 198.65039922297, "GFLOP/s": 1227.4388798755585, "strategy_time": 0, "framework_time": 1.1367108672857285, "timestamp": "2023-12-21 10:50:40.976863+00:00"},
+"16,4,1,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.125882595777512, "times": [6.154469013214111, 6.124229907989502, 6.120549201965332, 6.126629829406738, 6.12375020980835, 6.12598991394043, 6.122469902038574, 6.126309871673584, 6.1227898597717285, 6.124229907989502, 6.123088836669922, 6.137509822845459, 6.117990016937256, 6.127429962158203, 6.127110004425049, 6.125830173492432, 6.1247100830078125, 6.121510028839111, 6.125669956207275, 6.121509075164795, 6.127110004425049, 6.122579097747803, 6.124070167541504, 6.128550052642822, 6.1248698234558105, 6.128870010375977, 6.124229907989502, 6.127270221710205, 6.122629165649414, 6.126308917999268, 6.1186299324035645, 6.129350185394287], "compile_time": 386.2911369651556, "verification_time": 0, "benchmark_time": 197.44735909625888, "GFLOP/s": 1232.4341973520582, "strategy_time": 0, "framework_time": 1.2744367122650146, "timestamp": "2023-12-21 10:50:41.561891+00:00"},
+"16,4,1,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.37510025501251, "times": [33.433658599853516, 33.37462615966797, 33.36725997924805, 33.389015197753906, 33.34197998046875, 33.3444938659668, 33.34661865234375, 33.39984893798828, 33.331260681152344, 33.370933532714844, 33.3674201965332, 33.385921478271484, 33.39413833618164, 33.32536697387695, 33.346778869628906, 33.346527099609375, 33.3659782409668, 33.38778305053711, 33.37253952026367, 33.393150329589844, 33.34870147705078, 33.390533447265625, 33.380218505859375, 33.336246490478516, 33.35749816894531, 33.61326217651367, 33.36869812011719, 33.33284378051758, 33.38277816772461, 33.36341857910156, 33.376220703125, 33.367488861083984], "compile_time": 3224.8222082853317, "verification_time": 0, "benchmark_time": 1069.6545620448887, "GFLOP/s": 226.20897442446258, "strategy_time": 0, "framework_time": 1.3552336022257805, "timestamp": "2023-12-21 10:50:45.857738+00:00"},
+"16,4,1,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.242562264204025, "times": [10.305557250976562, 10.30939769744873, 10.25915813446045, 10.259157180786133, 10.249556541442871, 10.231316566467285, 10.233772277832031, 10.251956939697266, 10.221237182617188, 10.2545166015625, 10.250197410583496, 10.215316772460938, 10.28267765045166, 10.213560104370117, 10.241236686706543, 10.245396614074707, 10.243956565856934, 10.221076011657715, 10.213715553283691, 10.222676277160645, 10.227155685424805, 10.242676734924316, 10.23963737487793, 10.269556999206543, 10.230517387390137, 10.236916542053223, 10.238515853881836, 10.216873168945312, 10.24571704864502, 10.225076675415039, 10.229717254638672, 10.234195709228516], "compile_time": 449.27499908953905, "verification_time": 0, "benchmark_time": 329.12195520475507, "GFLOP/s": 737.0955631273098, "strategy_time": 0, "framework_time": 1.4553377404808998, "timestamp": "2023-12-21 10:50:46.637607+00:00"},
+"16,4,1,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.598525583744049, "times": [10.678840637207031, 10.620281219482422, 10.598200798034668, 10.563640594482422, 10.596281051635742, 10.584071159362793, 10.609881401062012, 10.628121376037598, 10.624760627746582, 10.590360641479492, 10.566040992736816, 10.593034744262695, 10.608281135559082, 10.616121292114258, 10.638681411743164, 10.577240943908691, 10.590041160583496, 10.567249298095703, 10.636920928955078, 10.583160400390625, 10.561400413513184, 10.594840049743652, 10.610040664672852, 10.602112770080566, 10.631160736083984, 10.565720558166504, 10.595641136169434, 10.608281135559082, 10.562360763549805, 10.58212661743164, 10.59580135345459, 10.572120666503906], "compile_time": 449.78864397853613, "verification_time": 0, "benchmark_time": 340.7082920894027, "GFLOP/s": 712.3393853556153, "strategy_time": 0, "framework_time": 1.4863279648125172, "timestamp": "2023-12-21 10:50:47.429605+00:00"},
+"16,4,1,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.207568287849426, "times": [34.57303237915039, 34.21023178100586, 34.22311019897461, 34.2041130065918, 34.18999099731445, 34.20487976074219, 34.22983169555664, 34.21293258666992, 34.22679138183594, 34.25580978393555, 34.27271270751953, 34.254024505615234, 34.236873626708984, 34.204139709472656, 34.197513580322266, 34.2155876159668, 34.164390563964844, 34.21959686279297, 34.18311309814453, 34.219383239746094, 34.14391326904297, 34.164085388183594, 34.1898307800293, 34.172183990478516, 34.15703201293945, 34.148189544677734, 34.15815353393555, 34.144432067871094, 34.137351989746094, 34.19187927246094, 34.17463302612305, 34.16244125366211], "compile_time": 4116.387207992375, "verification_time": 0, "benchmark_time": 1096.258212812245, "GFLOP/s": 220.7040014206938, "strategy_time": 0, "framework_time": 1.3467073440551758, "timestamp": "2023-12-21 10:50:52.643613+00:00"},
+"16,4,1,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 10.979285657405853, "times": [10.93596363067627, 11.207167625427246, 11.019805908203125, 11.01308536529541, 11.05676555633545, 10.877237319946289, 10.859643936157227, 10.874524116516113, 10.944125175476074, 10.969245910644531, 10.987324714660645, 10.842880249023438, 11.124127388000488, 11.098687171936035, 10.969245910644531, 10.95980453491211, 11.164127349853516, 10.967460632324219, 11.18044662475586, 11.021565437316895, 10.907644271850586, 11.05004596710205, 11.051165580749512, 10.851719856262207, 10.978525161743164, 10.95212459564209, 10.969884872436523, 10.957884788513184, 10.848283767700195, 10.870779037475586, 10.921884536743164, 10.903964042663574], "compile_time": 448.8570489920676, "verification_time": 0, "benchmark_time": 352.78385784476995, "GFLOP/s": 687.6355562265084, "strategy_time": 0, "framework_time": 1.3416782021522522, "timestamp": "2023-12-21 10:50:53.446610+00:00"},
+"16,4,1,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 13.19440758228302, "times": [13.274870872497559, 13.213590621948242, 13.176470756530762, 13.206550598144531, 13.157983779907227, 13.212471008300781, 13.17134952545166, 13.154069900512695, 13.172149658203125, 13.405607223510742, 13.2036714553833, 13.229110717773438, 13.155670166015625, 13.171509742736816, 13.21644401550293, 13.19198989868164, 13.211831092834473, 13.193429946899414, 13.202231407165527, 13.147509574890137, 13.170390129089355, 13.224310874938965, 13.196150779724121, 13.127510070800781, 13.17392635345459, 13.171509742736816, 13.174070358276367, 13.1668701171875, 13.193111419677734, 13.19342041015625, 13.179030418395996, 13.182229995727539], "compile_time": 453.9084006100893, "verification_time": 0, "benchmark_time": 423.8067166879773, "GFLOP/s": 572.1929653088428, "strategy_time": 0, "framework_time": 1.3346564956009388, "timestamp": "2023-12-21 10:50:54.325676+00:00"},
+"16,4,1,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.9091676771640778, "times": [3.2560360431671143, 2.9008328914642334, 2.904512882232666, 2.888032913208008, 2.902592897415161, 2.900512933731079, 2.901153087615967, 2.8949129581451416, 2.9059529304504395, 2.892193078994751, 2.8989129066467285, 2.8955531120300293, 2.900512933731079, 2.893152952194214, 2.900192975997925, 2.9038729667663574, 2.8976330757141113, 2.9072329998016357, 2.9091529846191406, 2.907233953475952, 2.8897929191589355, 2.8992180824279785, 2.887073040008545, 2.8867530822753906, 2.89443302154541, 2.8888330459594727, 2.904512882232666, 2.910753011703491, 2.90787410736084, 2.887073040008545, 2.8926730155944824, 2.884192943572998], "compile_time": 641.9726312160492, "verification_time": 0, "benchmark_time": 94.52216699719429, "GFLOP/s": 2595.1571163335843, "strategy_time": 0, "framework_time": 1.2807599268853664, "timestamp": "2023-12-21 10:50:55.063467+00:00"},
+"16,4,1,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 4.374451830983162, "times": [4.402129173278809, 4.3750901222229, 4.367569923400879, 4.365330219268799, 4.385970115661621, 4.369009971618652, 4.364049911499023, 4.366929054260254, 4.366448879241943, 4.364530086517334, 4.369009971618652, 4.365809917449951, 4.366448879241943, 4.365009784698486, 4.366240978240967, 4.3702898025512695, 4.365650177001953, 4.364689826965332, 4.568212985992432, 4.365809917449951, 4.367249965667725, 4.364530086517334, 4.363409996032715, 4.365809917449951, 4.364368915557861, 4.365809917449951, 4.371250152587891, 4.364850044250488, 4.364209175109863, 4.369600772857666, 4.364049911499023, 4.3630900382995605], "compile_time": 521.1012046784163, "verification_time": 0, "benchmark_time": 141.3220278918743, "GFLOP/s": 1725.8727474210607, "strategy_time": 0, "framework_time": 1.3707256875932217, "timestamp": "2023-12-21 10:50:55.727276+00:00"},
+"16,4,1,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 4.370569586753845, "times": [4.716533184051514, 4.372049808502197, 4.362450122833252, 4.358768939971924, 4.356049060821533, 4.356689929962158, 4.361169815063477, 4.357649803161621, 4.363890171051025, 4.362450122833252, 4.357649803161621, 4.360690116882324, 4.355889797210693, 4.358609199523926, 4.362606048583984, 4.359729766845703, 4.358610153198242, 4.363249778747559, 4.357170104980469, 4.3584489822387695, 4.358129978179932, 4.355090141296387, 4.357649803161621, 4.36116886138916, 4.356369972229004, 4.359889984130859, 4.357649803161621, 4.361649990081787, 4.357169151306152, 4.357804775238037, 4.355889797210693, 4.359409809112549], "compile_time": 520.4662550240755, "verification_time": 0, "benchmark_time": 141.3636188954115, "GFLOP/s": 1727.405787767682, "strategy_time": 0, "framework_time": 1.2141820043325424, "timestamp": "2023-12-21 10:50:56.390335+00:00"},
+"16,4,1,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.2320325076580048, "times": [3.272836923599243, 3.2357170581817627, 3.2363569736480713, 3.228037118911743, 3.2235569953918457, 3.2281970977783203, 3.2163569927215576, 3.2294769287109375, 3.2366769313812256, 3.2277169227600098, 3.205796957015991, 3.2365169525146484, 3.2397170066833496, 3.2272369861602783, 3.229796886444092, 3.2118759155273438, 3.230756998062134, 3.2214770317077637, 3.231877088546753, 3.229336977005005, 3.219717025756836, 3.214916944503784, 3.2221169471740723, 3.2208359241485596, 3.2139570713043213, 3.2296369075775146, 3.217315912246704, 3.396998882293701, 3.2206759452819824, 3.2147560119628906, 3.2233970165252686, 3.2313969135284424], "compile_time": 589.6776081062853, "verification_time": 0, "benchmark_time": 104.96168490499258, "GFLOP/s": 2335.913138903017, "strategy_time": 0, "framework_time": 1.1494453065097332, "timestamp": "2023-12-21 10:50:57.086139+00:00"},
+"16,4,1,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 4.373048201203346, "times": [4.409809112548828, 4.381810188293457, 4.376689910888672, 4.369009971618652, 4.3702898025512695, 4.37076997756958, 4.370610237121582, 4.370610237121582, 4.3722100257873535, 4.37460994720459, 4.369649887084961, 4.372690200805664, 4.371409893035889, 4.368850231170654, 4.369355201721191, 4.3742899894714355, 4.370449066162109, 4.3750901222229, 4.3701300621032715, 4.368370056152344, 4.370450019836426, 4.37076997756958, 4.370450019836426, 4.375889778137207, 4.375249862670898, 4.371729850769043, 4.3722100257873535, 4.371890068054199, 4.370928764343262, 4.3692498207092285, 4.369009971618652, 4.373010158538818], "compile_time": 517.2395170666277, "verification_time": 0, "benchmark_time": 141.39897795394063, "GFLOP/s": 1726.4267057295435, "strategy_time": 0, "framework_time": 1.3479599729180336, "timestamp": "2023-12-21 10:50:57.746141+00:00"},
+"16,4,1,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 4.362709939479828, "times": [4.400369167327881, 4.3661298751831055, 4.371409893035889, 4.36421012878418, 4.361649990081787, 4.365330219268799, 4.357970237731934, 4.360209941864014, 4.359409809112549, 4.359729766845703, 4.357809066772461, 4.362929821014404, 4.360690116882324, 4.361969947814941, 4.364785194396973, 4.363729000091553, 4.356369972229004, 4.35653018951416, 4.358129978179932, 4.359889030456543, 4.360690116882324, 4.360849857330322, 4.3610100746154785, 4.36116886138916, 4.360690116882324, 4.362770080566406, 4.359570026397705, 4.361810207366943, 4.357648849487305, 4.365078926086426, 4.366769790649414, 4.359409809112549], "compile_time": 517.8470928221941, "verification_time": 0, "benchmark_time": 141.00856194272637, "GFLOP/s": 1730.5177985085497, "strategy_time": 0, "framework_time": 1.3249358162283897, "timestamp": "2023-12-21 10:50:58.406336+00:00"},
+"16,4,2,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.848629027605057, "times": [5.885826110839844, 5.798305988311768, 5.906308174133301, 6.054308891296387, 5.867106914520264, 5.8181471824646, 5.835267066955566, 5.829987049102783, 5.825345993041992, 5.820706844329834, 5.906734943389893, 5.83142614364624, 5.8632659912109375, 5.813665866851807, 5.816707134246826, 5.7887067794799805, 5.829346179962158, 5.811106204986572, 5.89350700378418, 5.834627151489258, 5.80886697769165, 5.798908233642578, 5.90006685256958, 6.000868797302246, 5.824866771697998, 5.834465980529785, 5.793187141418457, 5.868227005004883, 5.799746036529541, 5.850787162780762, 5.818787097930908, 5.826947212219238], "compile_time": 960.4267249815166, "verification_time": 0, "benchmark_time": 188.5763886384666, "GFLOP/s": 1290.857594893744, "strategy_time": 0, "framework_time": 1.371357124298811, "timestamp": "2023-12-21 10:50:59.556726+00:00"},
+"16,4,2,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.518850058317184, "times": [9.548587799072266, 9.522028923034668, 9.526188850402832, 9.5148286819458, 9.51546859741211, 9.515789031982422, 9.51427173614502, 9.515949249267578, 9.523468971252441, 9.516907691955566, 9.523468971252441, 9.516749382019043, 9.52090835571289, 9.51842212677002, 9.524588584899902, 9.5148286819458, 9.520909309387207, 9.513387680053711, 9.517868041992188, 9.514669418334961, 9.517903327941895, 9.521707534790039, 9.508909225463867, 9.517548561096191, 9.517068862915039, 9.519309043884277, 9.52138900756836, 9.516441345214844, 9.5181884765625, 9.517229080200195, 9.5148286819458, 9.513388633728027], "compile_time": 424.65113289654255, "verification_time": 0, "benchmark_time": 306.05784989893436, "GFLOP/s": 793.1364769637628, "strategy_time": 0, "framework_time": 1.2285090051591396, "timestamp": "2023-12-21 10:51:00.288678+00:00"},
+"16,4,2,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.478515923023224, "times": [9.50186824798584, 9.476107597351074, 9.477388381958008, 9.47178840637207, 9.466987609863281, 9.472587585449219, 9.47373104095459, 9.47194766998291, 9.468268394470215, 9.45882797241211, 9.472587585449219, 9.469067573547363, 9.666191101074219, 9.474198341369629, 9.469388008117676, 9.46762752532959, 9.472587585449219, 9.475309371948242, 9.469548225402832, 9.472747802734375, 9.469223976135254, 9.481867790222168, 9.468268394470215, 9.467947959899902, 9.46922779083252, 9.46762752532959, 9.470507621765137, 9.47329044342041, 9.471467971801758, 9.480267524719238, 9.473068237304688, 9.470988273620605], "compile_time": 425.2547617070377, "verification_time": 0, "benchmark_time": 305.22584868595004, "GFLOP/s": 796.5115278924347, "strategy_time": 0, "framework_time": 1.288415864109993, "timestamp": "2023-12-21 10:51:01.020463+00:00"},
+"16,4,2,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7604751326143742, "times": [1.7958600521087646, 1.7670609951019287, 1.761620044708252, 1.7641799449920654, 1.7611409425735474, 1.7589000463485718, 1.7574599981307983, 1.7582600116729736, 1.763219952583313, 1.759060025215149, 1.7568199634552002, 1.7641799449920654, 1.7589000463485718, 1.7568199634552002, 1.7561800479888916, 1.759220004081726, 1.7581000328063965, 1.7581000328063965, 1.7577799558639526, 1.7579410076141357, 1.7579400539398193, 1.7581000328063965, 1.7579400539398193, 1.7576199769973755, 1.7624200582504272, 1.757140040397644, 1.757140040397644, 1.7573000192642212, 1.7601799964904785, 1.7606600522994995, 1.7584209442138672, 1.7595399618148804], "compile_time": 479.4783899560571, "verification_time": 0, "benchmark_time": 57.787529192864895, "GFLOP/s": 4288.471367833711, "strategy_time": 0, "framework_time": 1.3231919147074223, "timestamp": "2023-12-21 10:51:01.559066+00:00"},
+"16,4,2,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.523770362138748, "times": [9.547628402709961, 9.520269393920898, 9.523789405822754, 9.5050687789917, 9.51978874206543, 9.524748802185059, 9.512717247009277, 9.516907691955566, 9.512907981872559, 9.517068862915039, 9.516109466552734, 9.519628524780273, 9.51546859741211, 9.51848316192627, 9.511947631835938, 9.513228416442871, 9.515628814697266, 9.514509201049805, 9.512589454650879, 9.516589164733887, 9.516464233398438, 9.707630157470703, 9.528267860412598, 9.517228126525879, 9.511789321899414, 9.520427703857422, 9.51562786102295, 9.515542984008789, 9.5181884765625, 9.519309043884277, 9.516589164733887, 9.518508911132812], "compile_time": 418.1576380506158, "verification_time": 0, "benchmark_time": 306.0555546544492, "GFLOP/s": 792.7267156727786, "strategy_time": 0, "framework_time": 1.3170810416340828, "timestamp": "2023-12-21 10:51:02.284611+00:00"},
+"16,4,2,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.468466728925705, "times": [9.502187728881836, 9.470667839050293, 9.46426773071289, 9.466668128967285, 9.466507911682129, 9.466028213500977, 9.465850830078125, 9.466188430786133, 9.464588165283203, 9.469388008117676, 9.459628105163574, 9.46746826171875, 9.472268104553223, 9.467013359069824, 9.471307754516602, 9.470027923583984, 9.463788032531738, 9.46922779083252, 9.466828346252441, 9.467787742614746, 9.468454360961914, 9.47018814086914, 9.465228080749512, 9.465228080749512, 9.471628189086914, 9.469868659973145, 9.468108177185059, 9.464351654052734, 9.469708442687988, 9.46762752532959, 9.46586799621582, 9.466987609863281], "compile_time": 419.5547238923609, "verification_time": 0, "benchmark_time": 304.8900789581239, "GFLOP/s": 797.3568916851015, "strategy_time": 0, "framework_time": 1.3295738026499748, "timestamp": "2023-12-21 10:51:03.010402+00:00"},
+"16,4,2,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.4920583218336105, "times": [5.5175018310546875, 5.490303039550781, 5.4936628341674805, 5.485823154449463, 5.4839019775390625, 5.486301898956299, 5.489181995391846, 5.483423233032227, 5.488223075866699, 5.485342979431152, 5.481983184814453, 5.482947826385498, 5.486142158508301, 5.4866228103637695, 5.483582973480225, 5.485503196716309, 5.491582870483398, 5.482943058013916, 5.488382816314697, 5.478621959686279, 5.484861850738525, 5.481182098388672, 5.487422943115234, 5.481035232543945, 5.479903221130371, 5.485823154449463, 5.4794230461120605, 5.484063148498535, 5.481342792510986, 5.4818220138549805, 5.67942476272583, 5.487583160400391], "compile_time": 1429.7252101823688, "verification_time": 0, "benchmark_time": 177.4507937952876, "GFLOP/s": 1374.6662467122887, "strategy_time": 0, "framework_time": 1.375255174934864, "timestamp": "2023-12-21 10:51:04.618969+00:00"},
+"16,4,2,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.9834144115448, "times": [6.018467903137207, 5.984067916870117, 5.978949069976807, 5.980388164520264, 5.984707832336426, 5.9823079109191895, 5.980228900909424, 5.982627868652344, 5.986148834228516, 5.981828212738037, 5.979706764221191, 5.98118782043457, 5.984228134155273, 5.978147983551025, 5.977667808532715, 5.985669136047363, 5.98118782043457, 5.9864678382873535, 5.984868049621582, 5.981828212738037, 5.984707832336426, 5.982871055603027, 5.97894811630249, 5.982627868652344, 5.987267971038818, 5.981987953186035, 5.9823079109191895, 5.9823079109191895, 5.978787899017334, 5.982627868652344, 5.98118782043457, 5.9829487800598145], "compile_time": 610.7338927686214, "verification_time": 0, "benchmark_time": 192.436043638736, "GFLOP/s": 1261.779091455376, "strategy_time": 0, "framework_time": 1.3907034881412983, "timestamp": "2023-12-21 10:51:05.423545+00:00"},
+"16,4,2,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.949949637055397, "times": [5.976546764373779, 5.951908111572266, 5.951908111572266, 5.945347785949707, 5.951427936553955, 5.952548027038574, 5.950948238372803, 5.950307846069336, 5.9437479972839355, 5.949987888336182, 5.950364112854004, 5.950468063354492, 5.939908027648926, 5.948068141937256, 5.952387809753418, 5.952548027038574, 5.96262788772583, 5.951427936553955, 5.941348075866699, 5.941187858581543, 5.942788124084473, 5.95158576965332, 5.942148208618164, 5.953668117523193, 5.952548027038574, 5.952707767486572, 5.951747894287109, 5.94406795501709, 5.952387809753418, 5.944228172302246, 5.952387809753418, 5.943108081817627], "compile_time": 612.0432796888053, "verification_time": 0, "benchmark_time": 192.10245832800865, "GFLOP/s": 1268.875815852508, "strategy_time": 0, "framework_time": 1.3596732169389725, "timestamp": "2023-12-21 10:51:06.229065+00:00"},
+"16,4,2,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.1692934073507786, "times": [1.200173020362854, 1.1692930459976196, 1.167052984237671, 1.162093997001648, 1.1632139682769775, 1.1635329723358154, 1.1609729528427124, 1.3953759670257568, 1.1627329587936401, 1.1593730449676514, 1.160014033317566, 1.1601730585098267, 1.1566530466079712, 1.159693956375122, 1.1596930027008057, 1.160493016242981, 1.165132999420166, 1.158094048500061, 1.158092975616455, 1.1572929620742798, 1.1590540409088135, 1.1649739742279053, 1.1590529680252075, 1.1608129739761353, 1.1603339910507202, 1.1593730449676514, 1.158573031425476, 1.1588939428329468, 1.1587330102920532, 1.1577730178833008, 1.157454013824463, 1.1632130146026611], "compile_time": 668.6374968849123, "verification_time": 0, "benchmark_time": 38.89511292800307, "GFLOP/s": 6456.674734107293, "strategy_time": 0, "framework_time": 1.3216999359428883, "timestamp": "2023-12-21 10:51:06.937935+00:00"},
+"16,4,2,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.9770746529102325, "times": [6.008868217468262, 5.977668762207031, 5.977667808532715, 5.978147983551025, 5.979107856750488, 5.974308013916016, 5.973507881164551, 5.97846794128418, 5.972708225250244, 5.9731879234313965, 5.974184989929199, 5.975748062133789, 5.978949069976807, 5.977027893066406, 5.979107856750488, 5.979747772216797, 5.974788188934326, 5.976868152618408, 5.978308200836182, 5.975748062133789, 5.975428104400635, 5.974158763885498, 5.976068019866943, 5.976068019866943, 5.972228050231934, 5.97654914855957, 5.976707935333252, 5.977508068084717, 5.974147796630859, 5.973988056182861, 5.974789142608643, 5.974628925323486], "compile_time": 607.8834538348019, "verification_time": 0, "benchmark_time": 192.76105286553502, "GFLOP/s": 1263.1174342659472, "strategy_time": 0, "framework_time": 1.2142620980739594, "timestamp": "2023-12-21 10:51:07.739810+00:00"},
+"16,4,2,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.948254868388176, "times": [5.975586891174316, 5.947268009185791, 5.953668117523193, 5.94406795501709, 5.942946910858154, 5.939268112182617, 5.948227882385254, 5.94022798538208, 5.938467979431152, 5.936068058013916, 5.939267158508301, 5.9416680335998535, 5.938147068023682, 5.938307762145996, 5.951266765594482, 5.937828063964844, 6.147271156311035, 5.9416680335998535, 5.940547943115234, 5.950307846069336, 5.9461469650268555, 5.935334205627441, 5.9283881187438965, 5.937346935272217, 5.9376678466796875, 5.939267158508301, 5.9375081062316895, 5.937986850738525, 5.938787937164307, 5.940388202667236, 5.933507919311523, 5.9397478103637695], "compile_time": 608.7704007513821, "verification_time": 0, "benchmark_time": 192.34027806669474, "GFLOP/s": 1269.237342219969, "strategy_time": 0, "framework_time": 1.3292250223457813, "timestamp": "2023-12-21 10:51:08.542265+00:00"},
+"16,4,2,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 31.957833528518677, "times": [32.024044036865234, 32.01748275756836, 32.12372970581055, 31.9053955078125, 32.02900314331055, 31.96017074584961, 32.062767028808594, 31.904279708862305, 31.857484817504883, 31.84185028076172, 31.90244483947754, 32.08594512939453, 31.859724044799805, 32.03546905517578, 32.02660369873047, 32.04514694213867, 31.884523391723633, 31.780920028686523, 31.92916488647461, 31.83348274230957, 32.10532760620117, 31.918081283569336, 31.884843826293945, 31.840707778930664, 32.089324951171875, 32.05577087402344, 31.953964233398438, 32.03447341918945, 32.02052307128906, 31.884374618530273, 31.862443923950195, 31.891204833984375], "compile_time": 1732.3293630033731, "verification_time": 0, "benchmark_time": 1024.202711880207, "GFLOP/s": 236.24089515525893, "strategy_time": 0, "framework_time": 1.3193553313612938, "timestamp": "2023-12-21 10:51:11.300133+00:00"},
+"16,4,2,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.722479283809662, "times": [16.792512893676758, 16.62834930419922, 16.784992218017578, 16.721614837646484, 16.741470336914062, 16.763071060180664, 16.689149856567383, 16.7673282623291, 16.646270751953125, 16.69523048400879, 16.732030868530273, 16.744970321655273, 16.712671279907227, 16.67667007446289, 16.74947166442871, 16.628402709960938, 16.72035026550293, 16.75731086730957, 16.660350799560547, 16.763883590698242, 16.643230438232422, 16.676509857177734, 16.68450927734375, 16.735902786254883, 16.75507164001465, 16.916831970214844, 16.751230239868164, 16.691055297851562, 16.70931053161621, 16.728830337524414, 16.72195053100586, 16.728801727294922], "compile_time": 866.8361329473555, "verification_time": 0, "benchmark_time": 536.7940939031541, "GFLOP/s": 451.4729587561516, "strategy_time": 0, "framework_time": 1.4211209490895271, "timestamp": "2023-12-21 10:51:12.705201+00:00"},
+"16,4,2,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 17.321075975894928, "times": [17.387359619140625, 17.377920150756836, 17.39232063293457, 17.37293815612793, 17.545759201049805, 17.35919952392578, 17.259838104248047, 17.351131439208984, 17.349599838256836, 17.31376075744629, 17.289920806884766, 17.35124397277832, 17.273117065429688, 17.243677139282227, 17.247358322143555, 17.338165283203125, 17.18703842163086, 17.296960830688477, 17.351999282836914, 17.30458641052246, 17.286237716674805, 17.352479934692383, 17.33024024963379, 17.224063873291016, 17.349599838256836, 17.339040756225586, 17.34079933166504, 17.224212646484375, 17.287357330322266, 17.31648063659668, 17.312639236450195, 17.317384719848633], "compile_time": 864.8536861874163, "verification_time": 0, "benchmark_time": 555.7634579017758, "GFLOP/s": 435.87056661530096, "strategy_time": 0, "framework_time": 0.21583866328001022, "timestamp": "2023-12-21 11:07:06.463347+00:00"},
+"16,4,2,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 31.333716988563538, "times": [31.410207748413086, 31.189895629882812, 31.300128936767578, 31.502269744873047, 31.263967514038086, 31.353572845458984, 31.23580551147461, 31.4525089263916, 31.259328842163086, 31.38192367553711, 31.60717010498047, 31.19933319091797, 31.366687774658203, 31.192626953125, 31.27292823791504, 31.373380661010742, 31.215805053710938, 31.349716186523438, 31.409727096557617, 31.57097053527832, 31.20236587524414, 31.28144073486328, 31.231006622314453, 31.46980857849121, 31.166044235229492, 31.405847549438477, 31.36412811279297, 31.310657501220703, 31.480287551879883, 31.33137321472168, 31.441247940063477, 31.086780548095703], "compile_time": 1921.699620783329, "verification_time": 0, "benchmark_time": 1004.3435352854431, "GFLOP/s": 240.94642849922897, "strategy_time": 0, "framework_time": 2.810077276080847, "timestamp": "2023-12-21 11:07:09.392216+00:00"},
+"16,4,2,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.701884150505066, "times": [16.74335289001465, 16.683032989501953, 16.744474411010742, 16.754318237304688, 16.692472457885742, 16.718873977661133, 16.865915298461914, 16.598440170288086, 16.76655387878418, 16.635032653808594, 16.74687385559082, 16.676889419555664, 16.722232818603516, 16.69967269897461, 16.646392822265625, 16.76210594177246, 16.64223289489746, 16.660633087158203, 16.681432723999023, 16.66523551940918, 16.7121524810791, 16.68431282043457, 16.660152435302734, 16.660655975341797, 16.70623207092285, 16.71375274658203, 16.710874557495117, 16.7432804107666, 16.723352432250977, 16.695993423461914, 16.73151397705078, 16.61185073852539], "compile_time": 857.600836083293, "verification_time": 0, "benchmark_time": 536.0332089476287, "GFLOP/s": 452.0296711417253, "strategy_time": 0, "framework_time": 0.9298832155764103, "timestamp": "2023-12-21 11:07:10.786796+00:00"},
+"16,4,2,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 17.322689533233643, "times": [17.343997955322266, 17.33216094970703, 17.33839988708496, 17.2821044921875, 17.325599670410156, 17.35327911376953, 17.189437866210938, 17.324661254882812, 17.33247947692871, 17.394399642944336, 17.353599548339844, 17.304895401000977, 17.3351993560791, 17.31903839111328, 17.417760848999023, 17.33110237121582, 17.42095947265625, 17.30255889892578, 17.37727928161621, 17.230064392089844, 17.3038387298584, 17.387680053710938, 17.33679962158203, 17.2961368560791, 17.2451171875, 17.339839935302734, 17.353919982910156, 17.192867279052734, 17.360000610351562, 17.306720733642578, 17.27071762084961, 17.323448181152344], "compile_time": 870.3884570859373, "verification_time": 0, "benchmark_time": 555.9754278510809, "GFLOP/s": 435.82996656008766, "strategy_time": 0, "framework_time": 0.8848351426422596, "timestamp": "2023-12-21 11:07:12.214060+00:00"},
+"16,4,2,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.119757756590843, "times": [6.156216144561768, 6.11333703994751, 6.129655838012695, 6.1042160987854, 6.085334777832031, 6.1085357666015625, 6.1053361892700195, 6.111735820770264, 6.1125359535217285, 6.102136135101318, 6.108428955078125, 6.102615833282471, 6.131256103515625, 6.105976104736328, 6.277177810668945, 6.129177093505859, 6.104856014251709, 6.11845588684082, 6.126777172088623, 6.110775947570801, 6.115896224975586, 6.119414806365967, 6.109015941619873, 6.090456008911133, 6.117815971374512, 6.105815887451172, 6.120855808258057, 6.126296043395996, 6.1328558921813965, 6.10373592376709, 6.138296127319336, 6.107256889343262], "compile_time": 1051.3996360823512, "verification_time": 0, "benchmark_time": 197.63424526900053, "GFLOP/s": 1233.6676548788373, "strategy_time": 0, "framework_time": 1.4285985380411148, "timestamp": "2023-12-21 11:07:13.464538+00:00"},
+"16,4,2,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.860260918736458, "times": [5.951253890991211, 5.876694202423096, 5.845492839813232, 5.836213111877441, 5.873653888702393, 5.878133773803711, 5.839413166046143, 5.822772979736328, 5.831733226776123, 5.834932804107666, 5.843411922454834, 5.838132858276367, 5.828214168548584, 5.881013870239258, 5.88741397857666, 5.872854232788086, 5.875254154205322, 5.863733768463135, 5.865973949432373, 5.865172863006592, 5.900214195251465, 5.855167865753174, 5.8602142333984375, 5.870773792266846, 5.857493877410889, 5.82869291305542, 5.8715739250183105, 5.868693828582764, 5.87317419052124, 5.8317341804504395, 5.873653888702393, 5.825492858886719], "compile_time": 1132.9176928848028, "verification_time": 0, "benchmark_time": 189.28379705175757, "GFLOP/s": 1288.2954026606405, "strategy_time": 0, "framework_time": 1.5088249929249287, "timestamp": "2023-12-21 11:07:14.788263+00:00"},
+"16,4,2,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.007447198033333, "times": [6.095254898071289, 6.007894992828369, 5.991735935211182, 5.994295120239258, 6.0122151374816895, 5.9898152351379395, 5.993014812469482, 6.000535011291504, 6.003735065460205, 5.9904561042785645, 6.009486198425293, 5.986774921417236, 5.991574764251709, 5.993334770202637, 6.011735916137695, 5.989655017852783, 6.006295204162598, 5.979734897613525, 5.99637508392334, 5.980374813079834, 5.999734878540039, 5.982048988342285, 6.021975040435791, 6.16629695892334, 6.0030951499938965, 6.019415855407715, 5.998775005340576, 6.000854969024658, 6.018614768981934, 6.011254787445068, 5.996695041656494, 5.995254993438721], "compile_time": 1133.677985984832, "verification_time": 0, "benchmark_time": 193.84980900213122, "GFLOP/s": 1256.7313454659363, "strategy_time": 0, "framework_time": 1.4817831106483936, "timestamp": "2023-12-21 11:07:16.117289+00:00"},
+"16,4,2,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.639841169118881, "times": [5.722291946411133, 5.634611129760742, 5.610930919647217, 5.650132179260254, 5.6598920822143555, 5.6416521072387695, 5.623412132263184, 5.651892185211182, 5.651412010192871, 5.638291835784912, 5.641003131866455, 5.642131805419922, 5.646932125091553, 5.640692234039307, 5.658452033996582, 5.606451034545898, 5.63621187210083, 5.639091968536377, 5.639091968536377, 5.591251850128174, 5.649971961975098, 5.654932022094727, 5.647078037261963, 5.619411945343018, 5.636372089385986, 5.616531848907471, 5.639411926269531, 5.6374921798706055, 5.630931854248047, 5.635891914367676, 5.641491889953613, 5.639571189880371], "compile_time": 1264.2373032867908, "verification_time": 0, "benchmark_time": 181.88654724508524, "GFLOP/s": 1338.6453578407254, "strategy_time": 0, "framework_time": 1.5764953568577766, "timestamp": "2023-12-21 11:07:17.565004+00:00"},
+"16,4,2,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.123345702886581, "times": [6.226777076721191, 6.1619768142700195, 6.162137031555176, 6.137815952301025, 6.119736194610596, 6.098135948181152, 6.161497116088867, 6.160376071929932, 6.0922160148620605, 6.124695777893066, 6.084400177001953, 6.124375820159912, 6.102935791015625, 6.129655838012695, 6.135577201843262, 6.101016044616699, 6.0859761238098145, 6.114296913146973, 6.117015838623047, 6.109816074371338, 6.112696170806885, 6.140814781188965, 6.101816177368164, 6.118456840515137, 6.11029577255249, 6.137495994567871, 6.098936080932617, 6.121656894683838, 6.105016231536865, 6.1104559898376465, 6.104695796966553, 6.13429594039917], "compile_time": 1151.7166760750115, "verification_time": 0, "benchmark_time": 197.52292893826962, "GFLOP/s": 1232.9447929815565, "strategy_time": 0, "framework_time": 1.4656409621238708, "timestamp": "2023-12-21 11:07:18.915726+00:00"},
+"16,4,2,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.252481311559677, "times": [6.4667792320251465, 6.29381799697876, 6.288218021392822, 6.239418029785156, 6.265337944030762, 6.245017051696777, 6.208056926727295, 6.226138114929199, 6.236058235168457, 6.224130153656006, 6.230297088623047, 6.255417823791504, 6.264857769012451, 6.254938125610352, 6.217658042907715, 6.2326979637146, 6.268057823181152, 6.241978168487549, 6.231576919555664, 6.231123924255371, 6.283897876739502, 6.247898101806641, 6.238936901092529, 6.245017051696777, 6.253016948699951, 6.239256858825684, 6.237817764282227, 6.250457763671875, 6.2349371910095215, 6.226315975189209, 6.236697196960449, 6.263576984405518], "compile_time": 1151.2576760724187, "verification_time": 0, "benchmark_time": 201.50380628183484, "GFLOP/s": 1207.4801704791853, "strategy_time": 0, "framework_time": 1.3636425137519836, "timestamp": "2023-12-21 11:07:20.269867+00:00"},
+"16,4,3,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.04894292354584, "times": [33.28046417236328, 33.085819244384766, 33.05598449707031, 33.020450592041016, 33.03742218017578, 33.007347106933594, 33.02238464355469, 33.049110412597656, 33.08174514770508, 33.047828674316406, 33.06254577636719, 32.90570831298828, 33.03998565673828, 33.02696228027344, 33.077423095703125, 32.919090270996094, 33.08302307128906, 33.02070236206055, 33.09630584716797, 33.117496490478516, 33.08686447143555, 33.0567626953125, 32.947025299072266, 33.00971221923828, 33.09806442260742, 32.93824005126953, 33.016143798828125, 33.105918884277344, 33.13886642456055, 33.069637298583984, 32.98878479003906, 33.07235336303711], "compile_time": 2390.195704996586, "verification_time": 0, "benchmark_time": 1059.1132789850235, "GFLOP/s": 228.44141240660244, "strategy_time": 0, "framework_time": 1.4784960076212883, "timestamp": "2023-12-21 11:07:23.720670+00:00"},
+"16,4,3,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.992433935403824, "times": [16.10382843017578, 15.87598705291748, 16.0633487701416, 16.157325744628906, 15.891986846923828, 15.897746086120605, 15.818865776062012, 16.13090705871582, 15.831665992736816, 16.17551040649414, 16.43439292907715, 15.874898910522461, 15.89294719696045, 15.955347061157227, 16.150548934936523, 16.06036949157715, 15.868307113647461, 15.991827964782715, 15.89998722076416, 16.182641983032227, 16.00702667236328, 15.576944351196289, 15.828466415405273, 16.004314422607422, 16.13886833190918, 15.976946830749512, 15.737424850463867, 16.124401092529297, 15.908946990966797, 15.9935884475708, 16.2332706451416, 15.969245910644531], "compile_time": 543.6273920349777, "verification_time": 0, "benchmark_time": 513.3873289451003, "GFLOP/s": 472.08243788873665, "strategy_time": 0, "framework_time": 1.4939960092306137, "timestamp": "2023-12-21 11:07:24.779195+00:00"},
+"16,4,3,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.632707357406616, "times": [16.654552459716797, 16.59519386291504, 16.64911460876465, 16.694257736206055, 16.60687255859375, 16.597593307495117, 16.68079376220703, 16.682756423950195, 16.685754776000977, 16.647193908691406, 16.591672897338867, 16.61088752746582, 16.664794921875, 16.678394317626953, 16.618873596191406, 16.682327270507812, 16.611352920532227, 16.639833450317383, 16.625272750854492, 16.662939071655273, 16.60799217224121, 16.623512268066406, 16.613752365112305, 16.64659309387207, 16.596153259277344, 16.567672729492188, 16.568952560424805, 16.60753631591797, 16.711193084716797, 16.551992416381836, 16.6148738861084, 16.65597915649414], "compile_time": 543.9326134510338, "verification_time": 0, "benchmark_time": 533.7956720031798, "GFLOP/s": 453.90969959187464, "strategy_time": 0, "framework_time": 1.382610760629177, "timestamp": "2023-12-21 11:07:25.858321+00:00"},
+"16,4,3,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.0715194940567, "times": [33.38542938232422, 33.1341667175293, 33.022705078125, 33.086856842041016, 33.095985412597656, 33.06165313720703, 33.04238510131836, 33.078392028808594, 33.061424255371094, 33.08408737182617, 32.90542221069336, 33.0699577331543, 33.07710647583008, 33.1171989440918, 33.045902252197266, 33.03797149658203, 33.129905700683594, 33.056846618652344, 32.95822525024414, 32.848594665527344, 33.2132682800293, 33.10590744018555, 33.02974319458008, 33.063568115234375, 33.06782531738281, 32.9964485168457, 33.0551872253418, 33.06866455078125, 33.10686492919922, 33.10712432861328, 33.199188232421875, 32.97461700439453], "compile_time": 4625.592126045376, "verification_time": 0, "benchmark_time": 1059.923095162958, "GFLOP/s": 228.2854648198662, "strategy_time": 0, "framework_time": 1.3117026537656784, "timestamp": "2023-12-21 11:07:31.545164+00:00"},
+"16,4,3,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.035626590251923, "times": [15.949907302856445, 15.86462688446045, 16.005268096923828, 15.901474952697754, 15.976628303527832, 15.897907257080078, 16.008628845214844, 15.974113464355469, 15.966387748718262, 16.02286720275879, 16.090869903564453, 16.177034378051758, 16.22863006591797, 16.12750816345215, 16.019508361816406, 16.086421966552734, 15.870866775512695, 16.135509490966797, 16.072629928588867, 16.05029296875, 15.943826675415039, 16.054868698120117, 15.921587944030762, 15.968050003051758, 16.27967071533203, 16.008628845214844, 16.056148529052734, 16.197784423828125, 16.180950164794922, 16.046388626098633, 16.11294937133789, 15.94211483001709], "compile_time": 542.6114751026034, "verification_time": 0, "benchmark_time": 514.6504607982934, "GFLOP/s": 470.8108633927346, "strategy_time": 0, "framework_time": 1.416926272213459, "timestamp": "2023-12-21 11:07:32.603858+00:00"},
+"16,4,3,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 16.749551594257355, "times": [16.86815643310547, 16.75519561767578, 16.769115447998047, 16.781879425048828, 16.778076171875, 16.650074005126953, 16.74063491821289, 16.71600341796875, 16.681913375854492, 16.696474075317383, 16.734394073486328, 16.695772171020508, 16.802396774291992, 16.749114990234375, 16.678075790405273, 16.78757667541504, 16.716474533081055, 16.749914169311523, 16.672473907470703, 16.71358871459961, 16.744155883789062, 16.764795303344727, 16.736154556274414, 16.774295806884766, 16.734235763549805, 16.779035568237305, 16.751035690307617, 16.80996322631836, 16.72687530517578, 16.747194290161133, 16.93375587463379, 16.746849060058594], "compile_time": 543.6354307457805, "verification_time": 0, "benchmark_time": 537.676899228245, "GFLOP/s": 450.74324273782105, "strategy_time": 0, "framework_time": 1.4119460247457027, "timestamp": "2023-12-21 11:07:33.686597+00:00"},
+"16,4,3,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 32.171732902526855, "times": [31.828134536743164, 32.262718200683594, 31.93181610107422, 32.2447624206543, 32.28173828125, 32.36189270019531, 32.01741409301758, 32.047035217285156, 32.071495056152344, 32.090049743652344, 32.345420837402344, 32.35148239135742, 32.071014404296875, 32.190643310546875, 32.20733642578125, 31.910051345825195, 32.25933837890625, 32.409061431884766, 32.0150146484375, 32.40169143676758, 32.14141845703125, 32.161155700683594, 32.28990173339844, 31.745641708374023, 32.28062057495117, 32.24747848510742, 32.18893814086914, 32.23931884765625, 32.45117950439453, 32.22153091430664, 31.852296829223633, 32.37786102294922], "compile_time": 1656.4057618379593, "verification_time": 0, "benchmark_time": 1031.003993935883, "GFLOP/s": 234.67020638502885, "strategy_time": 0, "framework_time": 1.4521353878080845, "timestamp": "2023-12-21 11:07:36.375475+00:00"},
+"16,4,3,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.56039011478424, "times": [19.821624755859375, 19.552339553833008, 19.602739334106445, 19.600444793701172, 19.49842071533203, 19.564180374145508, 19.54210090637207, 19.520797729492188, 19.574581146240234, 19.60386085510254, 19.540180206298828, 19.601318359375, 19.487539291381836, 19.536020278930664, 19.5318603515625, 19.54513931274414, 19.545940399169922, 19.519699096679688, 19.516019821166992, 19.57681655883789, 19.558420181274414, 19.5673828125, 19.581140518188477, 19.505210876464844, 19.558420181274414, 19.53809928894043, 19.543380737304688, 19.595487594604492, 19.571060180664062, 19.505460739135742, 19.578899383544922, 19.547897338867188], "compile_time": 939.1877520829439, "verification_time": 0, "benchmark_time": 627.5580492801964, "GFLOP/s": 385.97119769578154, "strategy_time": 0, "framework_time": 1.4387895353138447, "timestamp": "2023-12-21 11:07:37.943675+00:00"},
+"16,4,3,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.615883886814117, "times": [20.813472747802734, 20.63363265991211, 20.63587188720703, 20.578411102294922, 20.610431671142578, 20.638111114501953, 20.66339111328125, 20.8046875, 20.614112854003906, 20.58403205871582, 20.59075164794922, 20.599103927612305, 20.612672805786133, 20.63203239440918, 20.60963249206543, 20.61524772644043, 20.563392639160156, 20.593311309814453, 20.59075164794922, 20.604555130004883, 20.593631744384766, 20.5889892578125, 20.599390029907227, 20.611204147338867, 20.560352325439453, 20.575231552124023, 20.5627498626709, 20.592527389526367, 20.5894718170166, 20.614112854003906, 20.626272201538086, 20.60674476623535], "compile_time": 913.4095688350499, "verification_time": 0, "benchmark_time": 661.3401276990771, "GFLOP/s": 366.2102115752022, "strategy_time": 0, "framework_time": 1.3519213534891605, "timestamp": "2023-12-21 11:07:39.519793+00:00"},
+"16,4,3,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 31.741502821445465, "times": [31.7318115234375, 31.859779357910156, 31.802215576171875, 31.586076736450195, 31.656291961669922, 31.579044342041016, 31.96397590637207, 31.8167724609375, 31.805736541748047, 31.762737274169922, 31.76973533630371, 31.74559211730957, 31.800935745239258, 31.615915298461914, 31.688453674316406, 32.07022476196289, 31.70909309387207, 31.78035545349121, 31.94749641418457, 31.612585067749023, 31.720773696899414, 31.876985549926758, 31.64429473876953, 31.75638198852539, 31.72605323791504, 31.629600524902344, 31.65869140625, 31.568166732788086, 31.77933692932129, 31.661151885986328, 31.698213577270508, 31.703611373901367], "compile_time": 1855.0710757263005, "verification_time": 0, "benchmark_time": 1017.3056181520224, "GFLOP/s": 237.85096888667712, "strategy_time": 0, "framework_time": 1.4194929972290993, "timestamp": "2023-12-21 11:07:42.393605+00:00"},
+"16,4,3,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.349627375602722, "times": [19.46769905090332, 19.385940551757812, 19.4489803314209, 19.39292335510254, 19.337940216064453, 19.336660385131836, 19.3104190826416, 19.369943618774414, 19.30497932434082, 19.278099060058594, 19.351219177246094, 19.298940658569336, 19.35681915283203, 19.381139755249023, 19.315540313720703, 19.30770492553711, 19.40258026123047, 19.518259048461914, 19.373619079589844, 19.3065242767334, 19.322420120239258, 19.35025978088379, 19.3057804107666, 19.3046875, 19.33057975769043, 19.324979782104492, 19.337459564208984, 19.301483154296875, 19.340660095214844, 19.305299758911133, 19.359060287475586, 19.359474182128906], "compile_time": 907.5260139070451, "verification_time": 0, "benchmark_time": 620.6830409355462, "GFLOP/s": 390.17532758895476, "strategy_time": 0, "framework_time": 1.4929142780601978, "timestamp": "2023-12-21 11:07:43.923322+00:00"},
+"16,4,3,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.418754875659943, "times": [20.43794822692871, 20.490909576416016, 20.467870712280273, 20.487720489501953, 20.39394760131836, 20.382427215576172, 20.403709411621094, 20.439556121826172, 20.4190673828125, 20.445310592651367, 20.385787963867188, 20.41170883178711, 20.39474868774414, 20.37906837463379, 20.4360294342041, 20.42222023010254, 20.465309143066406, 20.40850830078125, 20.43042755126953, 20.437105178833008, 20.382587432861328, 20.40658950805664, 20.419389724731445, 20.384302139282227, 20.373947143554688, 20.409950256347656, 20.420989990234375, 20.398052215576172, 20.42435073852539, 20.37074851989746, 20.42947006225586, 20.440397262573242], "compile_time": 906.9480341859162, "verification_time": 0, "benchmark_time": 654.967375099659, "GFLOP/s": 369.7457188733693, "strategy_time": 0, "framework_time": 1.5437309630215168, "timestamp": "2023-12-21 11:07:45.486797+00:00"},
+"16,4,3,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.470404624938965, "times": [40.37653732299805, 40.582210540771484, 40.621177673339844, 40.44198226928711, 40.435096740722656, 40.4286003112793, 40.362457275390625, 40.69919204711914, 40.2738151550293, 40.27280807495117, 40.57621765136719, 40.60513687133789, 40.57029724121094, 40.543312072753906, 40.33973693847656, 40.30683898925781, 40.52549743652344, 40.48857116699219, 40.386775970458984, 40.50526428222656, 40.5605354309082, 40.343849182128906, 40.553497314453125, 40.345767974853516, 40.44917678833008, 40.52743911743164, 40.34581756591797, 40.56724548339844, 40.53541564941406, 40.34099197387695, 40.41989517211914, 40.7217903137207], "compile_time": 2597.6524259895086, "verification_time": 0, "benchmark_time": 1296.6625983826816, "GFLOP/s": 186.5498324014196, "strategy_time": 0, "framework_time": 1.4674346894025803, "timestamp": "2023-12-21 11:07:49.382595+00:00"},
+"16,4,3,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.341142535209656, "times": [19.55426025390625, 19.387380599975586, 19.351699829101562, 19.37162208557129, 19.33698081970215, 19.307540893554688, 19.298099517822266, 19.328556060791016, 19.355060577392578, 19.352340698242188, 19.321779251098633, 19.32841682434082, 19.306419372558594, 19.306259155273438, 19.305299758911133, 19.298782348632812, 19.353139877319336, 19.33698081970215, 19.38081932067871, 19.298616409301758, 19.334579467773438, 19.289140701293945, 19.328819274902344, 19.321935653686523, 19.35186004638672, 19.347700119018555, 19.3572998046875, 19.39986801147461, 19.350419998168945, 19.27713966369629, 19.34593963623047, 19.331804275512695], "compile_time": 1295.3103072941303, "verification_time": 0, "benchmark_time": 620.628276374191, "GFLOP/s": 390.3464951078269, "strategy_time": 0, "framework_time": 1.3749045319855213, "timestamp": "2023-12-21 11:07:51.299924+00:00"},
+"16,4,3,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.310342371463776, "times": [21.377317428588867, 20.89315414428711, 20.82732391357422, 20.972196578979492, 20.877954483032227, 20.688045501708984, 20.16402816772461, 20.157947540283203, 20.11090850830078, 20.13987159729004, 20.162267684936523, 20.111068725585938, 20.192188262939453, 20.167312622070312, 20.16162872314453, 20.151227951049805, 20.178428649902344, 20.151527404785156, 20.209308624267578, 20.120027542114258, 20.18242835998535, 20.226032257080078, 20.191707611083984, 20.135547637939453, 20.15410804748535, 20.118120193481445, 20.205467224121094, 20.23938751220703, 20.180347442626953, 20.182899475097656, 20.15730857849121, 20.14386749267578], "compile_time": 1325.4933189600706, "verification_time": 0, "benchmark_time": 651.5868799760938, "GFLOP/s": 371.71934681945424, "strategy_time": 0, "framework_time": 1.4420761726796627, "timestamp": "2023-12-21 11:07:53.278462+00:00"},
+"16,4,3,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.402666449546814, "times": [40.54341506958008, 40.73997497558594, 40.35813522338867, 40.42063522338867, 40.77750015258789, 40.54803466796875, 40.20549774169922, 40.66712188720703, 39.9637336730957, 40.63920974731445, 40.1326904296875, 40.520328521728516, 40.29765701293945, 40.582366943359375, 40.519256591796875, 40.3388557434082, 39.8938102722168, 40.04189682006836, 40.51941680908203, 40.06315994262695, 40.22101593017578, 40.356082916259766, 40.53829574584961, 40.347408294677734, 40.57717514038086, 40.35616683959961, 40.15301513671875, 40.120330810546875, 40.423095703125, 40.511295318603516, 40.927581787109375, 40.5811653137207], "compile_time": 3156.474214978516, "verification_time": 0, "benchmark_time": 1294.4976310245693, "GFLOP/s": 186.8625975324627, "strategy_time": 0, "framework_time": 1.4257249422371387, "timestamp": "2023-12-21 11:07:57.730876+00:00"},
+"16,4,3,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.383474707603455, "times": [19.37778091430664, 19.43362045288086, 19.380979537963867, 19.373483657836914, 19.368499755859375, 19.372499465942383, 19.372499465942383, 19.345470428466797, 19.3923397064209, 19.341779708862305, 19.36993980407715, 19.33990478515625, 19.3289794921875, 19.417940139770508, 19.379539489746094, 19.37272834777832, 19.40802001953125, 19.405780792236328, 19.37425994873047, 19.41373634338379, 19.38450050354004, 19.437620162963867, 19.35025978088379, 19.39167594909668, 19.34946060180664, 19.36241912841797, 19.371219635009766, 19.429311752319336, 19.43313980102539, 19.40290069580078, 19.423540115356445, 19.365360260009766], "compile_time": 1285.993847064674, "verification_time": 0, "benchmark_time": 621.9002613797784, "GFLOP/s": 389.4940052744258, "strategy_time": 0, "framework_time": 1.3683023862540722, "timestamp": "2023-12-21 11:07:59.640154+00:00"},
+"16,4,3,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.4226011633873, "times": [20.60099220275879, 20.467071533203125, 20.492351531982422, 20.45635223388672, 20.426912307739258, 20.46227264404297, 20.449312210083008, 20.360088348388672, 20.432350158691406, 20.387229919433594, 20.396509170532227, 20.448978424072266, 20.368030548095703, 20.616992950439453, 20.402429580688477, 20.433340072631836, 20.36659049987793, 20.39219093322754, 20.45138931274414, 20.411035537719727, 20.47667121887207, 20.437471389770508, 20.406909942626953, 20.39582633972168, 20.372190475463867, 20.36387062072754, 20.39250946044922, 20.343975067138672, 20.39059066772461, 20.3552303314209, 20.379390716552734, 20.386180877685547], "compile_time": 1322.6498062722385, "verification_time": 0, "benchmark_time": 655.1239779219031, "GFLOP/s": 369.6760828652346, "strategy_time": 0, "framework_time": 1.51510676369071, "timestamp": "2023-12-21 11:08:01.619460+00:00"},
+"16,4,3,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.634443283081055, "times": [43.654808044433594, 43.72148895263672, 43.71704864501953, 43.743526458740234, 43.58680725097656, 43.52960968017578, 43.664886474609375, 43.69460678100586, 43.64408874511719, 43.49337387084961, 43.5280876159668, 43.68952560424805, 43.58952713012695, 43.59390640258789, 43.63944625854492, 43.658573150634766, 43.504249572753906, 43.65504837036133, 43.69784927368164, 43.60874557495117, 43.54712677001953, 43.6475830078125, 43.688568115234375, 43.654518127441406, 43.65128707885742, 43.6110954284668, 43.68680953979492, 43.70583724975586, 43.618648529052734, 43.60780715942383, 43.64584732055664, 43.62185287475586], "compile_time": 1777.1392818540335, "verification_time": 0, "benchmark_time": 1398.0902112089097, "GFLOP/s": 173.02265439759515, "strategy_time": 0, "framework_time": 1.4479868113994598, "timestamp": "2023-12-21 11:08:04.796153+00:00"},
+"16,4,3,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.217411309480667, "times": [7.418148040771484, 7.2221479415893555, 7.203426837921143, 7.218307018280029, 7.2195868492126465, 7.21494722366333, 7.197987079620361, 7.214306831359863, 7.193741798400879, 7.203907012939453, 7.204708099365234, 7.217827796936035, 7.210146903991699, 7.205347061157227, 7.194147109985352, 7.205987930297852, 7.215588092803955, 7.198616981506348, 7.188706874847412, 7.202307224273682, 7.184226989746094, 7.211906909942627, 7.38710880279541, 7.195587158203125, 7.216066837310791, 7.194626808166504, 7.205411911010742, 7.189187049865723, 7.205506801605225, 7.1920671463012695, 7.2186279296875, 7.206946849822998], "compile_time": 890.0163304060698, "verification_time": 0, "benchmark_time": 232.74289723485708, "GFLOP/s": 1046.0464114166227, "strategy_time": 0, "framework_time": 1.4144103042781353, "timestamp": "2023-12-21 11:08:05.920342+00:00"},
+"16,4,3,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.272494196891785, "times": [7.621510028839111, 7.271108150482178, 7.284388065338135, 7.2658281326293945, 7.260706901550293, 7.258947849273682, 7.2527079582214355, 7.268228054046631, 7.248459815979004, 7.266147136688232, 7.26774787902832, 7.268706798553467, 7.260548114776611, 7.255268096923828, 7.264388084411621, 7.262786865234375, 7.269028186798096, 7.251722812652588, 7.259428024291992, 7.255746841430664, 7.258148193359375, 7.260228157043457, 7.257828235626221, 7.255427837371826, 7.257347106933594, 7.253347873687744, 7.261985778808594, 7.264707088470459, 7.253828048706055, 7.249667167663574, 7.2663068771362305, 7.267588138580322], "compile_time": 885.8413668349385, "verification_time": 0, "benchmark_time": 234.43919466808438, "GFLOP/s": 1038.12350970685, "strategy_time": 0, "framework_time": 1.3496060855686665, "timestamp": "2023-12-21 11:08:07.041988+00:00"},
+"16,4,3,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.31587624549866, "times": [43.196083068847656, 43.38228988647461, 43.240562438964844, 43.46257781982422, 43.29736328125, 43.330467224121094, 43.22744369506836, 43.26062774658203, 43.25080490112305, 43.46531295776367, 43.567928314208984, 43.12638473510742, 43.47640609741211, 43.292991638183594, 43.20872497558594, 43.182918548583984, 43.319923400878906, 43.483150482177734, 43.43400955200195, 43.17681121826172, 43.30744552612305, 43.261268615722656, 43.257362365722656, 43.24647903442383, 43.22104263305664, 43.39586639404297, 43.45368957519531, 43.281429290771484, 43.214324951171875, 43.16525650024414, 43.41608428955078, 43.505008697509766], "compile_time": 2236.203114967793, "verification_time": 0, "benchmark_time": 1387.905238661915, "GFLOP/s": 174.29515120993452, "strategy_time": 0, "framework_time": 1.4969403855502605, "timestamp": "2023-12-21 11:08:10.667610+00:00"},
+"16,4,3,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.20599702000618, "times": [7.38726806640625, 7.207266807556152, 7.206147193908691, 7.2079081535339355, 7.1879072189331055, 7.205348014831543, 7.206626892089844, 7.193346977233887, 7.2075958251953125, 7.186946868896484, 7.187747001647949, 7.204867839813232, 7.183426856994629, 7.207907199859619, 7.195426940917969, 7.1920671463012695, 7.203106880187988, 7.19059419631958, 7.203907012939453, 7.196066856384277, 7.2242279052734375, 7.213347911834717, 7.197667121887207, 7.194467067718506, 7.196547031402588, 7.2011871337890625, 7.190323829650879, 7.198946952819824, 7.210786819458008, 7.2013468742370605, 7.201508045196533, 7.20006799697876], "compile_time": 883.2242637872696, "verification_time": 0, "benchmark_time": 232.60525986552238, "GFLOP/s": 1047.703347508951, "strategy_time": 0, "framework_time": 1.4716526493430138, "timestamp": "2023-12-21 11:08:11.784928+00:00"},
+"16,4,3,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.249379068613052, "times": [7.456708908081055, 7.258947849273682, 7.271907806396484, 7.246788024902344, 7.262787818908691, 7.2445478439331055, 7.237827777862549, 7.237827777862549, 7.248568058013916, 7.2328667640686035, 7.245028018951416, 7.245028018951416, 7.244067192077637, 7.249348163604736, 7.241668224334717, 7.240228176116943, 7.241026878356934, 7.232294082641602, 7.240706920623779, 7.238468170166016, 7.23446798324585, 7.231427192687988, 7.250466823577881, 7.244387149810791, 7.236547946929932, 7.2303080558776855, 7.236024856567383, 7.245666980743408, 7.227747917175293, 7.2375078201293945, 7.2485480308532715, 7.240386962890625], "compile_time": 889.473688788712, "verification_time": 0, "benchmark_time": 233.34106570109725, "GFLOP/s": 1041.433635700942, "strategy_time": 0, "framework_time": 1.4404724352061749, "timestamp": "2023-12-21 11:08:12.909199+00:00"},
+"16,4,4,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.6423177272081375, "times": [6.65286111831665, 6.649662017822266, 6.650301933288574, 6.6039018630981445, 6.646302223205566, 6.629662036895752, 6.670462131500244, 6.829183101654053, 6.669501781463623, 6.648665904998779, 6.645502090454102, 6.642941951751709, 6.669342041015625, 6.624701976776123, 6.627421855926514, 6.632381916046143, 6.68630313873291, 6.616861820220947, 6.648221969604492, 6.645771026611328, 6.625341892242432, 6.62838077545166, 6.614781856536865, 6.6301422119140625, 6.602301120758057, 6.636541843414307, 6.594461917877197, 6.628861904144287, 6.636541843414307, 6.624334812164307, 6.634302139282227, 6.608221054077148], "compile_time": 2901.77597803995, "verification_time": 0, "benchmark_time": 214.2648147419095, "GFLOP/s": 1136.6133795549806, "strategy_time": 0, "framework_time": 1.397659070789814, "timestamp": "2023-12-21 11:08:16.026653+00:00"},
+"16,4,4,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.222967803478241, "times": [9.270485877990723, 9.239606857299805, 9.230647087097168, 9.227766990661621, 9.22264575958252, 9.223126411437988, 9.249585151672363, 9.232246398925781, 9.219926834106445, 9.218646049499512, 9.224726676940918, 9.222167015075684, 9.21816635131836, 9.22028923034668, 9.218006134033203, 9.216245651245117, 9.216245651245117, 9.216726303100586, 9.21896743774414, 9.216086387634277, 9.216492652893066, 9.21656608581543, 9.217206001281738, 9.218965530395508, 9.219606399536133, 9.217206001281738, 9.218646049499512, 9.215946197509766, 9.215926170349121, 9.218646049499512, 9.217845916748047, 9.219606399536133], "compile_time": 645.9887279197574, "verification_time": 0, "benchmark_time": 296.7745461501181, "GFLOP/s": 818.581107607551, "strategy_time": 0, "framework_time": 1.3778912834823132, "timestamp": "2023-12-21 11:08:16.970810+00:00"},
+"16,4,4,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.149218589067459, "times": [9.19112491607666, 9.164565086364746, 9.15544605255127, 9.15064525604248, 9.142644882202148, 9.14200496673584, 9.142643928527832, 9.141365051269531, 9.139445304870605, 9.138805389404297, 9.136725425720215, 9.139124870300293, 9.141365051269531, 9.135407447814941, 9.13608455657959, 9.138484954833984, 9.323607444763184, 9.145686149597168, 9.150806427001953, 9.138006210327148, 9.136272430419922, 9.137365341186523, 9.138805389404297, 9.138646125793457, 9.137524604797363, 9.138006210327148, 9.145204544067383, 9.146920204162598, 9.141525268554688, 9.140085220336914, 9.141204833984375, 9.139445304870605], "compile_time": 652.9783383011818, "verification_time": 0, "benchmark_time": 294.6168929338455, "GFLOP/s": 825.1794540160301, "strategy_time": 0, "framework_time": 1.301321666687727, "timestamp": "2023-12-21 11:08:17.919722+00:00"},
+"16,4,4,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7216110900044441, "times": [1.758255958557129, 1.7320170402526855, 1.7228959798812866, 1.7233760356903076, 1.718256950378418, 1.7198560237884521, 1.7180960178375244, 1.725775957107544, 1.723855972290039, 1.721295952796936, 1.7195359468460083, 1.7211359739303589, 1.7203370332717896, 1.7222559452056885, 1.7200160026550293, 1.7182559967041016, 1.719215989112854, 1.7227360010147095, 1.7201759815216064, 1.7211359739303589, 1.7169760465621948, 1.7169760465621948, 1.7198560237884521, 1.7182559967041016, 1.7182559967041016, 1.719696044921875, 1.7233760356903076, 1.7209759950637817, 1.716655969619751, 1.714095950126648, 1.7204960584640503, 1.7174559831619263], "compile_time": 672.098794952035, "verification_time": 0, "benchmark_time": 56.378673762083054, "GFLOP/s": 4385.280301592685, "strategy_time": 0, "framework_time": 1.3288152404129505, "timestamp": "2023-12-21 11:08:18.649543+00:00"},
+"16,4,4,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.232358127832413, "times": [9.287125587463379, 9.255125999450684, 9.232405662536621, 9.226326942443848, 9.224885940551758, 9.226165771484375, 9.222315788269043, 9.220726013183594, 9.232887268066406, 9.22696590423584, 9.230006217956543, 9.220726013183594, 9.223925590515137, 9.218111038208008, 9.220086097717285, 9.233845710754395, 9.217206001281738, 9.21928596496582, 9.223127365112305, 9.216086387634277, 9.215620040893555, 9.219125747680664, 9.217846870422363, 9.21656608581543, 9.21816635131836, 9.443609237670898, 9.236565589904785, 9.222919464111328, 9.216726303100586, 9.219765663146973, 9.216405868530273, 9.214805603027344], "compile_time": 640.616494230926, "verification_time": 0, "benchmark_time": 296.9592232257128, "GFLOP/s": 817.7485205258757, "strategy_time": 0, "framework_time": 1.395434606820345, "timestamp": "2023-12-21 11:08:19.588530+00:00"},
+"16,4,4,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.146054595708847, "times": [9.191445350646973, 9.16008472442627, 9.15816593170166, 9.150165557861328, 9.14456558227539, 9.157365798950195, 9.145033836364746, 9.152565002441406, 9.142965316772461, 9.146164894104004, 9.139925003051758, 9.143765449523926, 9.137365341186523, 9.151188850402832, 9.142325401306152, 9.142166137695312, 9.138005256652832, 9.13608455657959, 9.13576602935791, 9.14776611328125, 9.147669792175293, 9.144564628601074, 9.142644882202148, 9.1431245803833, 9.142484664916992, 9.138805389404297, 9.133524894714355, 9.13786506652832, 9.137365341186523, 9.148085594177246, 9.144246101379395, 9.15048599243164], "compile_time": 641.2241221405566, "verification_time": 0, "benchmark_time": 294.4948561489582, "GFLOP/s": 825.4649172488206, "strategy_time": 0, "framework_time": 1.4645885676145554, "timestamp": "2023-12-21 11:08:20.525730+00:00"},
+"16,4,4,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.849453330039978, "times": [11.90731143951416, 11.939311981201172, 11.918191909790039, 11.809551239013672, 11.80763053894043, 11.828275680541992, 11.892431259155273, 11.864911079406738, 11.878511428833008, 11.86427116394043, 11.847790718078613, 11.851848602294922, 11.79146957397461, 11.847790718078613, 11.795310974121094, 11.877872467041016, 11.870990753173828, 11.795262336730957, 11.823150634765625, 11.85835075378418, 11.801711082458496, 11.909871101379395, 11.839151382446289, 11.882283210754395, 11.869710922241211, 11.83707046508789, 11.814510345458984, 11.886672019958496, 11.784270286560059, 11.865839958190918, 11.791790008544922, 11.829390525817871], "compile_time": 4903.460725210607, "verification_time": 0, "benchmark_time": 380.9410869143903, "GFLOP/s": 637.1388611540722, "strategy_time": 0, "framework_time": 1.3769781216979027, "timestamp": "2023-12-21 11:08:25.811524+00:00"},
+"16,4,4,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.9725663512945175, "times": [6.17669677734375, 5.97397518157959, 6.183578014373779, 5.976535797119141, 5.959735870361328, 5.957816123962402, 5.956855773925781, 5.96997594833374, 5.968535900115967, 5.95957612991333, 5.968440055847168, 5.956056118011475, 5.974775791168213, 5.971254825592041, 5.957815170288086, 5.953654766082764, 5.95573616027832, 5.968376159667969, 5.956215858459473, 5.951255798339844, 5.968376159667969, 5.948166847229004, 5.9478960037231445, 5.9518961906433105, 5.949975967407227, 5.9509358406066895, 5.948855876922607, 5.952855110168457, 5.951895236968994, 5.952055931091309, 5.951255798339844, 5.951096057891846], "compile_time": 1074.2321843281388, "verification_time": 0, "benchmark_time": 192.76126893237233, "GFLOP/s": 1264.0708794074155, "strategy_time": 0, "framework_time": 1.3895640149712563, "timestamp": "2023-12-21 11:08:27.079922+00:00"},
+"16,4,4,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.916371911764145, "times": [5.971415042877197, 5.942615032196045, 5.92325496673584, 5.925654888153076, 5.91285514831543, 5.915734767913818, 5.913014888763428, 5.923736095428467, 5.911896228790283, 5.917815208435059, 5.907309055328369, 5.903254985809326, 5.9056549072265625, 5.905655860900879, 5.9077348709106445, 5.9278950691223145, 5.917816162109375, 5.920536041259766, 5.906455039978027, 5.908695220947266, 5.923574924468994, 5.90997314453125, 5.9046950340271, 5.9054951667785645, 5.905974864959717, 5.914936065673828, 5.916056156158447, 5.926935195922852, 5.917335033416748, 5.911096096038818, 5.910614967346191, 5.908215045928955], "compile_time": 1077.4884358979762, "verification_time": 0, "benchmark_time": 191.0045938566327, "GFLOP/s": 1276.077182536149, "strategy_time": 0, "framework_time": 1.3715592212975025, "timestamp": "2023-12-21 11:08:28.349802+00:00"},
+"16,4,4,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.125137336552143, "times": [3.490432024002075, 3.1134700775146484, 3.118588924407959, 3.0987489223480225, 3.1128299236297607, 3.1139490604400635, 3.1040289402008057, 3.117310047149658, 3.1009891033172607, 3.1078689098358154, 3.0977890491485596, 3.1088290214538574, 3.314910888671875, 3.0942680835723877, 3.1097888946533203, 3.0957090854644775, 3.1061089038848877, 3.105149030685425, 3.1089890003204346, 3.1041269302368164, 3.102428913116455, 3.1056289672851562, 3.0989089012145996, 3.116668939590454, 3.1030690670013428, 3.094269037246704, 3.101149082183838, 3.116990089416504, 3.113468885421753, 3.1192290782928467, 3.10578989982605, 3.1029090881347656], "compile_time": 1112.5312387011945, "verification_time": 0, "benchmark_time": 101.4494551345706, "GFLOP/s": 2415.812934585901, "strategy_time": 0, "framework_time": 1.4143730513751507, "timestamp": "2023-12-21 11:08:29.565212+00:00"},
+"16,4,4,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.957276239991188, "times": [6.0010151863098145, 5.969655990600586, 5.960536003112793, 5.959255218505859, 5.96997594833374, 5.953815937042236, 5.9550957679748535, 5.9590959548950195, 5.9680562019348145, 5.952695846557617, 5.967327117919922, 5.952055931091309, 5.953495025634766, 5.952054977416992, 5.9635748863220215, 5.9498162269592285, 5.950136184692383, 5.949975967407227, 5.952536106109619, 5.948535919189453, 5.952215194702148, 5.947360038757324, 5.948855876922607, 5.964375972747803, 5.951735973358154, 5.950776100158691, 5.961336135864258, 5.947414875030518, 5.948375225067139, 5.950776100158691, 5.952055931091309, 5.968855857849121], "compile_time": 1088.6412570253015, "verification_time": 0, "benchmark_time": 192.36029218882322, "GFLOP/s": 1267.315278972386, "strategy_time": 0, "framework_time": 1.3890629634261131, "timestamp": "2023-12-21 11:08:30.847619+00:00"},
+"16,4,4,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.919791892170906, "times": [5.951895236968994, 5.92709493637085, 5.931095123291016, 5.912055015563965, 5.929495811462402, 5.908374786376953, 5.929335117340088, 5.913495063781738, 5.925334930419922, 5.906135082244873, 5.917055130004883, 5.905334949493408, 5.915736198425293, 5.905815124511719, 5.904214859008789, 5.904375076293945, 5.9056549072265625, 5.903415203094482, 5.901175022125244, 5.916696071624756, 5.9214959144592285, 5.907108783721924, 6.106936931610107, 5.912215232849121, 5.903735160827637, 5.9147748947143555, 5.907094955444336, 5.916214942932129, 5.902935028076172, 5.906774997711182, 5.918135166168213, 5.902134895324707], "compile_time": 1081.5530950203538, "verification_time": 0, "benchmark_time": 190.98715018481016, "GFLOP/s": 1275.3399676067593, "strategy_time": 0, "framework_time": 1.2939791195094585, "timestamp": "2023-12-21 11:08:32.121470+00:00"},
+"16,4,4,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 47.46589398384094, "times": [47.34156036376953, 47.350582122802734, 47.360923767089844, 47.30313491821289, 47.44508361816406, 47.41366958618164, 47.487483978271484, 47.5123291015625, 47.656288146972656, 47.430599212646484, 47.38668441772461, 47.66622543334961, 47.4831657409668, 47.66219711303711, 47.50108337402344, 47.42394256591797, 47.34780502319336, 47.404666900634766, 47.44012451171875, 47.572486877441406, 47.549564361572266, 47.536903381347656, 47.43692398071289, 47.46082305908203, 47.496604919433594, 47.37961196899414, 47.31436538696289, 47.57961654663086, 47.45852279663086, 47.45208740234375, 47.468284606933594, 47.585262298583984], "compile_time": 3401.517968159169, "verification_time": 0, "benchmark_time": 1520.4095537774265, "GFLOP/s": 159.05625210746476, "strategy_time": 0, "framework_time": 1.4167358167469501, "timestamp": "2023-12-21 11:08:37.044829+00:00"},
+"16,4,4,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.214600056409836, "times": [7.428069114685059, 7.213188171386719, 7.225986957550049, 7.208066940307617, 7.209987163543701, 7.208867073059082, 7.2037482261657715, 7.2018280029296875, 7.220558166503906, 7.204067230224609, 7.2170281410217285, 7.2151079177856445, 7.208548069000244, 7.204227924346924, 7.205347061157227, 7.193666934967041, 7.207266807556152, 7.189525127410889, 7.21478796005249, 7.221027851104736, 7.209668159484863, 7.229668140411377, 7.210787773132324, 7.1999077796936035, 7.206307888031006, 7.201986789703369, 7.193237781524658, 7.192546844482422, 7.202147006988525, 7.192226886749268, 7.215268135070801, 7.212547779083252], "compile_time": 877.8126030229032, "verification_time": 0, "benchmark_time": 232.72406868636608, "GFLOP/s": 1046.4540156030412, "strategy_time": 0, "framework_time": 1.4532674103975296, "timestamp": "2023-12-21 11:08:38.156835+00:00"},
+"16,4,4,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.149825274944305, "times": [7.445669174194336, 7.156385898590088, 7.1840667724609375, 7.152866840362549, 7.1402268409729, 7.136386871337891, 7.135746955871582, 7.139747142791748, 7.137903213500977, 7.128706932067871, 7.140867233276367, 7.138146877288818, 7.131906986236572, 7.130305767059326, 7.138947010040283, 7.123587131500244, 7.134626865386963, 7.149555206298828, 7.141026973724365, 7.147747039794922, 7.123745918273926, 7.131266117095947, 7.1411871910095215, 7.139586925506592, 7.146146774291992, 7.144707202911377, 7.137811183929443, 7.1352667808532715, 7.147266864776611, 7.135265827178955, 7.141507148742676, 7.136227130889893], "compile_time": 871.5030108578503, "verification_time": 0, "benchmark_time": 230.68842384964228, "GFLOP/s": 1055.9345032468377, "strategy_time": 0, "framework_time": 1.3533532619476318, "timestamp": "2023-12-21 11:08:39.260396+00:00"},
+"16,4,4,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 47.61623966693878, "times": [47.94268798828125, 47.432987213134766, 47.52940368652344, 47.955543518066406, 47.542362213134766, 47.83567810058594, 47.88636779785156, 47.45872497558594, 47.413883209228516, 47.79283905029297, 47.78668975830078, 47.64912033081055, 47.52300262451172, 47.39906692504883, 47.3822021484375, 47.53200912475586, 47.88796615600586, 47.85344696044922, 47.73740768432617, 47.70333480834961, 47.341243743896484, 47.42824935913086, 47.628929138183594, 47.49125671386719, 47.60364532470703, 47.638023376464844, 47.628604888916016, 47.31540298461914, 47.630043029785156, 47.4571418762207, 47.54076385498047, 47.77164077758789], "compile_time": 4383.880845271051, "verification_time": 0, "benchmark_time": 1525.1353457570076, "GFLOP/s": 158.55404065520926, "strategy_time": 0, "framework_time": 1.4408016577363014, "timestamp": "2023-12-21 11:08:45.170869+00:00"},
+"16,4,4,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.210557863116264, "times": [7.410469055175781, 7.216708183288574, 7.195908069610596, 7.196067810058594, 7.204068183898926, 7.193827152252197, 7.192866802215576, 7.205027103424072, 7.202660083770752, 7.199586868286133, 7.408548831939697, 7.196066856384277, 7.182948112487793, 7.189187049865723, 7.193346977233887, 7.1971869468688965, 7.197347164154053, 7.202998161315918, 7.176547050476074, 7.211748123168945, 7.182787895202637, 7.193187236785889, 7.186787128448486, 7.2263078689575195, 7.19094705581665, 7.225987911224365, 7.200954914093018, 7.186946868896484, 7.194147109985352, 7.1920671463012695, 7.19622802734375, 7.188387870788574], "compile_time": 881.2673888169229, "verification_time": 0, "benchmark_time": 232.42906760424376, "GFLOP/s": 1047.0406511289189, "strategy_time": 0, "framework_time": 1.4725355431437492, "timestamp": "2023-12-21 11:08:46.286054+00:00"},
+"16,4,4,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.125097468495369, "times": [7.187265872955322, 7.141026973724365, 7.138627052307129, 7.136867046356201, 7.1336669921875, 7.126626968383789, 7.12022590637207, 7.121826171875, 7.116364002227783, 7.11734676361084, 7.124547004699707, 7.12166690826416, 7.128546237945557, 7.108066082000732, 7.124547004699707, 7.112067222595215, 7.117665767669678, 7.136448860168457, 7.116705894470215, 7.115907192230225, 7.118465900421143, 7.1082258224487305, 7.109507083892822, 7.112226963043213, 7.13750696182251, 7.127266883850098, 7.123414039611816, 7.116546154022217, 7.142467021942139, 7.113027095794678, 7.116065979003906, 7.132387161254883], "compile_time": 876.1194101534784, "verification_time": 0, "benchmark_time": 229.65667257085443, "GFLOP/s": 1059.5991470126942, "strategy_time": 0, "framework_time": 1.3453778810799122, "timestamp": "2023-12-21 11:08:47.393191+00:00"},
+"16,4,4,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 13.705814272165298, "times": [13.614526748657227, 13.703968048095703, 13.741249084472656, 13.7457275390625, 13.739336967468262, 13.702207565307617, 13.716927528381348, 13.7042875289917, 13.695487976074219, 13.681276321411133, 13.67420768737793, 13.674528121948242, 13.764449119567871, 13.75036907196045, 13.670666694641113, 13.759649276733398, 13.723488807678223, 13.619647979736328, 13.659008026123047, 13.651729583740234, 13.90941047668457, 13.697728157043457, 13.740927696228027, 13.771808624267578, 13.61856746673584, 13.671487808227539, 13.667807579040527, 13.732768058776855, 13.641087532043457, 13.629146575927734, 13.75900936126709, 13.753567695617676], "compile_time": 1830.2222662605345, "verification_time": 0, "benchmark_time": 440.259809140116, "GFLOP/s": 550.8426606460398, "strategy_time": 0, "framework_time": 1.2615458108484745, "timestamp": "2023-12-21 11:08:49.664952+00:00"},
+"16,4,4,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.505290567874908, "times": [8.541519165039062, 8.519280433654785, 8.509519577026367, 8.510479927062988, 8.5154390335083, 8.496719360351562, 8.494318962097168, 8.536881446838379, 8.50391960144043, 8.496879577636719, 8.495439529418945, 8.494799613952637, 8.490638732910156, 8.491278648376465, 8.492718696594238, 8.498114585876465, 8.516239166259766, 8.507759094238281, 8.492719650268555, 8.4891996383667, 8.500399589538574, 8.4989595413208, 8.496399879455566, 8.542279243469238, 8.516719818115234, 8.497039794921875, 8.529840469360352, 8.503119468688965, 8.493518829345703, 8.499918937683105, 8.502799987792969, 8.494438171386719], "compile_time": 1260.7483360916376, "verification_time": 0, "benchmark_time": 273.6576208844781, "GFLOP/s": 887.6530601454035, "strategy_time": 0, "framework_time": 1.561738085001707, "timestamp": "2023-12-21 11:08:51.200935+00:00"},
+"16,4,4,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.43500131368637, "times": [8.471758842468262, 8.445359230041504, 8.435118675231934, 8.425678253173828, 8.420719146728516, 8.459918975830078, 8.425198554992676, 8.429886817932129, 8.462959289550781, 8.433198928833008, 8.423599243164062, 8.423759460449219, 8.42327880859375, 8.420878410339355, 8.41719913482666, 8.415335655212402, 8.418317794799805, 8.452559471130371, 8.421198844909668, 8.411917686462402, 8.415278434753418, 8.416238784790039, 8.414639472961426, 8.416655540466309, 8.412558555603027, 8.417518615722656, 8.449199676513672, 8.415279388427734, 8.446319580078125, 8.418478012084961, 8.595760345458984, 8.464274406433105], "compile_time": 1258.708472829312, "verification_time": 0, "benchmark_time": 271.48956805467606, "GFLOP/s": 895.0499139520007, "strategy_time": 0, "framework_time": 1.4437884092330933, "timestamp": "2023-12-21 11:08:52.732593+00:00"},
+"16,4,4,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.08564130961895, "times": [7.200706958770752, 7.064705848693848, 7.114466190338135, 7.061346054077148, 7.047266006469727, 7.089507102966309, 7.058145999908447, 7.0522260665893555, 7.098657131195068, 7.089345932006836, 7.121985912322998, 7.143907070159912, 7.06678581237793, 7.055426120758057, 7.071746826171875, 7.063586235046387, 7.102787017822266, 7.046021938323975, 7.077985763549805, 7.021184921264648, 7.136385917663574, 7.06678581237793, 7.0298261642456055, 7.145987033843994, 7.0954270362854, 7.100866794586182, 7.061598777770996, 7.07542610168457, 7.086307048797607, 7.070946216583252, 7.116066932678223, 7.107107162475586], "compile_time": 1403.2472488470376, "verification_time": 0, "benchmark_time": 228.32818841561675, "GFLOP/s": 1065.499489756984, "strategy_time": 0, "framework_time": 1.4129485934972763, "timestamp": "2023-12-21 11:08:54.365597+00:00"},
+"16,4,4,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.5019009411335, "times": [8.699761390686035, 8.528719902038574, 8.50679874420166, 8.506319046020508, 8.497200012207031, 8.505840301513672, 8.49512004852295, 8.500978469848633, 8.526000022888184, 8.495920181274414, 8.483280181884766, 8.494319915771484, 8.509039878845215, 8.498799324035645, 8.498478889465332, 8.496548652648926, 8.488719940185547, 8.480718612670898, 8.489358901977539, 8.48775863647461, 8.489679336547852, 8.484719276428223, 8.491920471191406, 8.485926628112793, 8.48871898651123, 8.489679336547852, 8.495280265808105, 8.484079360961914, 8.491120338439941, 8.489519119262695, 8.493359565734863, 8.487146377563477], "compile_time": 1254.2134379036725, "verification_time": 0, "benchmark_time": 273.6491756513715, "GFLOP/s": 888.0069589464595, "strategy_time": 0, "framework_time": 1.3179443776607513, "timestamp": "2023-12-21 11:08:55.894794+00:00"},
+"16,4,4,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 4, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.431461900472641, "times": [8.471598625183105, 8.43959903717041, 8.442000389099121, 8.429039001464844, 8.434799194335938, 8.419597625732422, 8.417038917541504, 8.640629768371582, 8.413839340209961, 8.41287899017334, 8.42055892944336, 8.413518905639648, 8.419757843017578, 8.411438941955566, 8.41127872467041, 8.41987133026123, 8.445999145507812, 8.451759338378906, 8.417678833007812, 8.41127872467041, 8.409358024597168, 8.417999267578125, 8.409358978271484, 8.421043395996094, 8.418478965759277, 8.416719436645508, 8.40695858001709, 8.453518867492676, 8.457359313964844, 8.423918724060059, 8.414798736572266, 8.413106918334961], "compile_time": 1254.465135280043, "verification_time": 0, "benchmark_time": 271.41883224248886, "GFLOP/s": 895.4256437518605, "strategy_time": 0, "framework_time": 1.430222298949957, "timestamp": "2023-12-21 11:08:57.422124+00:00"},
+"16,8,1,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.604685328900814, "times": [3.639233112335205, 3.6099541187286377, 3.6107540130615234, 3.604672908782959, 3.605154037475586, 3.6027541160583496, 3.6013131141662598, 3.605314016342163, 3.608354091644287, 3.6054739952087402, 3.6085140705108643, 3.6080338954925537, 3.605154037475586, 3.6078739166259766, 3.6046741008758545, 3.604193925857544, 3.602752923965454, 3.6047239303588867, 3.601314067840576, 3.5997140407562256, 3.6003530025482178, 3.5995540618896484, 3.604994058609009, 3.600512981414795, 3.597954034805298, 3.603394031524658, 3.5979530811309814, 3.598114013671875, 3.604353904724121, 3.6022729873657227, 3.6005139350891113, 3.60003399848938], "compile_time": 659.3489563092589, "verification_time": 0, "benchmark_time": 117.47383000329137, "GFLOP/s": 2094.4261457357675, "strategy_time": 0, "framework_time": 3.7574456073343754, "timestamp": "2023-12-21 11:08:58.202720+00:00"},
+"16,8,1,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.813957840204239, "times": [9.852890968322754, 9.819611549377441, 9.81417179107666, 9.810332298278809, 9.808411598205566, 9.807291030883789, 9.812474250793457, 9.811931610107422, 9.808411598205566, 9.809211730957031, 9.806652069091797, 9.797532081604004, 9.801212310791016, 9.803325653076172, 9.802491188049316, 9.806812286376953, 9.808252334594727, 9.99929428100586, 9.805212020874023, 9.807930946350098, 9.805319786071777, 9.803292274475098, 9.801852226257324, 9.803451538085938, 9.802652359008789, 9.80393123626709, 9.805212020874023, 9.816239356994629, 9.801212310791016, 9.80217170715332, 9.805691719055176, 9.802170753479004], "compile_time": 330.61372488737106, "verification_time": 0, "benchmark_time": 315.87874004617333, "GFLOP/s": 769.2866958396146, "strategy_time": 0, "framework_time": 1.291411928832531, "timestamp": "2023-12-21 11:08:58.850518+00:00"},
+"16,8,1,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.812505424022675, "times": [9.861532211303711, 9.83049201965332, 9.820571899414062, 9.817852020263672, 9.814650535583496, 9.813692092895508, 9.812666893005371, 9.81241226196289, 9.81241226196289, 9.81417179107666, 9.812091827392578, 9.805691719055176, 9.809532165527344, 9.809171676635742, 9.806012153625488, 9.806652069091797, 9.807291030883789, 9.806652069091797, 9.805691719055176, 9.805691719055176, 9.806745529174805, 9.810172080993652, 9.808892250061035, 9.806172370910645, 9.809211730957031, 9.806172370910645, 9.80537223815918, 9.810296058654785, 9.81241226196289, 9.812252044677734, 9.811930656433105, 9.815611839294434], "compile_time": 330.49966394901276, "verification_time": 0, "benchmark_time": 315.95053896307945, "GFLOP/s": 769.4005632360662, "strategy_time": 0, "framework_time": 1.2963335029780865, "timestamp": "2023-12-21 11:08:59.498280+00:00"},
+"16,8,1,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.8000368736684322, "times": [1.8299360275268555, 1.8030569553375244, 1.7956969738006592, 1.7968159914016724, 1.7953770160675049, 1.7947369813919067, 1.7924970388412476, 1.7928169965744019, 1.7936160564422607, 1.7931369543075562, 1.7916970252990723, 1.7926570177078247, 1.7923369407653809, 1.7921769618988037, 1.7937769889831543, 1.7916970252990723, 1.7926570177078247, 1.7916959524154663, 1.7948960065841675, 1.7923369407653809, 1.7952170372009277, 1.7820969820022583, 1.7947369813919067, 1.7936170101165771, 1.790416955947876, 1.7910560369491577, 1.7912169694900513, 1.9768190383911133, 1.7950570583343506, 1.7940969467163086, 1.7916970252990723, 1.7915370464324951], "compile_time": 349.6383740566671, "verification_time": 0, "benchmark_time": 59.51443174853921, "GFLOP/s": 4194.218079885105, "strategy_time": 0, "framework_time": 1.262337900698185, "timestamp": "2023-12-21 11:08:59.908710+00:00"},
+"16,8,1,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.801978141069412, "times": [9.852890968322754, 9.823931694030762, 9.815131187438965, 9.807291030883789, 9.805212020874023, 9.804251670837402, 9.800544738769531, 9.800091743469238, 9.799291610717773, 9.79945182800293, 9.796252250671387, 9.798490524291992, 9.795612335205078, 9.797675132751465, 9.796730995178223, 9.800251960754395, 9.800891876220703, 9.799931526184082, 9.795612335205078, 9.802652359008789, 9.795620918273926, 9.796570777893066, 9.796252250671387, 9.797532081604004, 9.795130729675293, 9.797532081604004, 9.80041217803955, 9.80145263671875, 9.798171997070312, 9.797532081604004, 9.79625129699707, 9.798651695251465], "compile_time": 330.45807387679815, "verification_time": 0, "benchmark_time": 315.5435500666499, "GFLOP/s": 770.2268961779494, "strategy_time": 0, "framework_time": 1.411715056747198, "timestamp": "2023-12-21 11:09:00.556138+00:00"},
+"16,8,1,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.809891372919083, "times": [9.861532211303711, 9.827611923217773, 9.818012237548828, 9.823772430419922, 9.810811996459961, 9.80809211730957, 9.810541152954102, 9.80985164642334, 9.806812286376953, 9.803611755371094, 9.806812286376953, 9.804411888122559, 9.810651779174805, 9.806690216064453, 9.80377197265625, 9.804891586303711, 9.80665111541748, 9.80649185180664, 9.80537223815918, 9.804571151733398, 9.804656982421875, 9.807771682739258, 9.803611755371094, 9.807291030883789, 9.806652069091797, 9.806652069091797, 9.804572105407715, 9.805983543395996, 9.807452201843262, 9.804891586303711, 9.807451248168945, 9.808571815490723], "compile_time": 326.70796336606145, "verification_time": 0, "benchmark_time": 315.90428901836276, "GFLOP/s": 769.6055861374393, "strategy_time": 0, "framework_time": 1.366929616779089, "timestamp": "2023-12-21 11:09:01.200133+00:00"},
+"16,8,1,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.4288684092462063, "times": [1.4587329626083374, 1.4382539987564087, 1.4260940551757812, 1.4238539934158325, 1.6347349882125854, 1.422732949256897, 1.422253966331482, 1.4220930337905884, 1.421293020248413, 1.4228930473327637, 1.4260940551757812, 1.4188929796218872, 1.4251329898834229, 1.4188940525054932, 1.4179329872131348, 1.4200129508972168, 1.4192140102386475, 1.418573021888733, 1.421133041381836, 1.4188929796218872, 1.4212939739227295, 1.4196929931640625, 1.418252944946289, 1.4200140237808228, 1.4174530506134033, 1.4174530506134033, 1.4200140237808228, 1.418573021888733, 1.418092966079712, 1.4190529584884644, 1.4179329872131348, 1.418254017829895], "compile_time": 482.8314371407032, "verification_time": 0, "benchmark_time": 47.16422129422426, "GFLOP/s": 5283.7246251268425, "strategy_time": 0, "framework_time": 1.2862137518823147, "timestamp": "2023-12-21 11:09:01.731431+00:00"},
+"16,8,1,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.305346101522446, "times": [7.347107887268066, 7.3218278884887695, 7.31414794921875, 7.30982780456543, 7.308067798614502, 7.308708190917969, 7.306148052215576, 7.305828094482422, 7.304272174835205, 7.304388046264648, 7.3064680099487305, 7.303267955780029, 7.301828861236572, 7.3034281730651855, 7.305188179016113, 7.300388813018799, 7.297668933868408, 7.301268100738525, 7.305347919464111, 7.301988124847412, 7.302787780761719, 7.300708770751953, 7.30214786529541, 7.299588203430176, 7.300229072570801, 7.302787780761719, 7.299877166748047, 7.299747943878174, 7.302787780761719, 7.302148818969727, 7.301668167114258, 7.299428939819336], "compile_time": 406.31466498598456, "verification_time": 0, "benchmark_time": 235.34775571897626, "GFLOP/s": 1033.4551019323535, "strategy_time": 0, "framework_time": 1.1508706957101822, "timestamp": "2023-12-21 11:09:02.374260+00:00"},
+"16,8,1,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.27861376106739, "times": [7.31846809387207, 7.285189151763916, 7.281027793884277, 7.277348041534424, 7.274787902832031, 7.273667812347412, 7.274788856506348, 7.2730278968811035, 7.269640922546387, 7.269668102264404, 7.267427921295166, 7.267908096313477, 7.266307830810547, 7.501030921936035, 7.272068023681641, 7.269507884979248, 7.267588138580322, 7.2719268798828125, 7.2658281326293945, 7.267107963562012, 7.267107963562012, 7.26774787902832, 7.266468048095703, 7.27158784866333, 7.267268180847168, 7.267427921295166, 7.266816139221191, 7.264708042144775, 7.264547824859619, 7.269028186798096, 7.264068126678467, 7.264547824859619], "compile_time": 404.95218290016055, "verification_time": 0, "benchmark_time": 234.78949395939708, "GFLOP/s": 1037.2506974312714, "strategy_time": 0, "framework_time": 1.5055094845592976, "timestamp": "2023-12-21 11:09:03.015522+00:00"},
+"16,8,1,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.4072331599891186, "times": [1.4438530206680298, 1.4128140211105347, 1.4115339517593384, 1.409132957458496, 1.407052993774414, 1.4057730436325073, 1.4076930284500122, 1.4121730327606201, 1.4057730436325073, 1.4060930013656616, 1.4052929878234863, 1.4049739837646484, 1.4054529666900635, 1.4040130376815796, 1.4033739566802979, 1.4065730571746826, 1.4049739837646484, 1.4052929878234863, 1.4048130512237549, 1.4033730030059814, 1.4032130241394043, 1.4116929769515991, 1.4041730165481567, 1.4052929878234863, 1.4043329954147339, 1.4056129455566406, 1.4048130512237549, 1.4038530588150024, 1.4056129455566406, 1.404492974281311, 1.404973030090332, 1.4033730030059814], "compile_time": 463.4715667925775, "verification_time": 0, "benchmark_time": 46.791677828878164, "GFLOP/s": 5364.958284566274, "strategy_time": 0, "framework_time": 1.3336464762687683, "timestamp": "2023-12-21 11:09:03.527135+00:00"},
+"16,8,1,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.308459490537643, "times": [7.349827766418457, 7.3258280754089355, 7.310147762298584, 7.309187889099121, 7.305828094482422, 7.303109169006348, 7.302309036254883, 7.302309036254883, 7.298211097717285, 7.300067901611328, 7.298149108886719, 7.300708770751953, 7.300868034362793, 7.299108982086182, 7.299588203430176, 7.301027774810791, 7.297668933868408, 7.297739028930664, 7.301187992095947, 7.297828197479248, 7.295108795166016, 7.2933478355407715, 7.294628143310547, 7.479750156402588, 7.297667980194092, 7.296388149261475, 7.2966108322143555, 7.3013482093811035, 7.303907871246338, 7.31174898147583, 7.302947998046875, 7.296547889709473], "compile_time": 409.9483788013458, "verification_time": 0, "benchmark_time": 235.38191290572286, "GFLOP/s": 1033.0148521415156, "strategy_time": 0, "framework_time": 1.2569664977490902, "timestamp": "2023-12-21 11:09:04.173738+00:00"},
+"16,8,1,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.267999917268753, "times": [7.313988208770752, 7.281027793884277, 7.2800679206848145, 7.276547908782959, 7.271267890930176, 7.27158784866333, 7.267268180847168, 7.266307830810547, 7.264904022216797, 7.268228054046631, 7.26502799987793, 7.266627788543701, 7.265667915344238, 7.266307830810547, 7.266948223114014, 7.268708229064941, 7.263107776641846, 7.262378215789795, 7.262467861175537, 7.262467861175537, 7.264068126678467, 7.263107776641846, 7.266148090362549, 7.266788005828857, 7.26118803024292, 7.265509128570557, 7.264983177185059, 7.264227867126465, 7.262147903442383, 7.262787818908691, 7.262467861175537, 7.2616682052612305], "compile_time": 403.2634301111102, "verification_time": 0, "benchmark_time": 234.25610922276974, "GFLOP/s": 1038.7654493586076, "strategy_time": 0, "framework_time": 1.7836778424680233, "timestamp": "2023-12-21 11:09:04.813057+00:00"},
+"16,8,1,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.834455728530884, "times": [33.92575454711914, 33.878929138183594, 33.79967498779297, 33.81586456298828, 33.894554138183594, 33.780113220214844, 33.8305549621582, 33.882057189941406, 33.82719421386719, 33.89091110229492, 33.82511520385742, 33.89861297607422, 33.842716217041016, 33.7821044921875, 33.83439636230469, 33.797691345214844, 33.744956970214844, 33.80537414550781, 33.79855728149414, 33.81975555419922, 33.7945556640625, 33.945438385009766, 33.89919662475586, 33.77473449707031, 33.81727600097656, 33.78386306762695, 33.786075592041016, 33.900760650634766, 33.823516845703125, 33.79380416870117, 33.839515686035156, 33.86895751953125], "compile_time": 3101.293283049017, "verification_time": 0, "benchmark_time": 1084.3426929786801, "GFLOP/s": 223.1378350098205, "strategy_time": 0, "framework_time": 1.2881569564342499, "timestamp": "2023-12-21 11:09:08.999996+00:00"},
+"16,8,1,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.729024350643158, "times": [12.06811237335205, 11.66266918182373, 11.664588928222656, 11.731789588928223, 11.670989036560059, 11.697607040405273, 11.78378963470459, 11.70634937286377, 11.675788879394531, 11.781710624694824, 11.744429588317871, 11.65480899810791, 11.728589057922363, 11.73723030090332, 11.700590133666992, 11.718990325927734, 11.692429542541504, 11.760656356811523, 11.673389434814453, 11.749549865722656, 11.661548614501953, 11.795949935913086, 11.718029975891113, 11.673479080200195, 11.778989791870117, 11.769070625305176, 11.801070213317871, 11.691629409790039, 11.719148635864258, 11.698785781860352, 11.702348709106445, 11.714670181274414], "compile_time": 483.4351381286979, "verification_time": 0, "benchmark_time": 376.86992483213544, "GFLOP/s": 643.6807507852101, "strategy_time": 0, "framework_time": 1.4140410348773003, "timestamp": "2023-12-21 11:09:09.861730+00:00"},
+"16,8,1,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.9875148832798, "times": [11.996591567993164, 12.099152565002441, 11.880910873413086, 12.14859390258789, 12.069232940673828, 12.021918296813965, 11.824431419372559, 12.065552711486816, 12.022831916809082, 11.93419075012207, 12.050832748413086, 12.061745643615723, 11.892431259155273, 12.022671699523926, 11.904911041259766, 11.927472114562988, 11.947312355041504, 11.798314094543457, 11.98795223236084, 11.961551666259766, 12.19035530090332, 11.878512382507324, 11.976271629333496, 11.878177642822266, 12.156434059143066, 12.026192665100098, 11.94923210144043, 11.98939323425293, 12.191794395446777, 11.880327224731445, 11.97323226928711, 11.891951560974121], "compile_time": 486.66229424998164, "verification_time": 0, "benchmark_time": 385.1393861696124, "GFLOP/s": 629.8008614387954, "strategy_time": 0, "framework_time": 1.3115517795085907, "timestamp": "2023-12-21 11:09:10.734859+00:00"},
+"16,8,1,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.280083894729614, "times": [34.38768005371094, 34.328800201416016, 34.32271957397461, 34.31402587890625, 34.21263885498047, 34.34259033203125, 34.26464080810547, 34.31367111206055, 34.2270393371582, 34.28558349609375, 34.48784255981445, 34.29597091674805, 34.260318756103516, 34.304588317871094, 34.312320709228516, 34.213382720947266, 34.23440170288086, 34.32164001464844, 34.25392150878906, 34.2686767578125, 34.28384017944336, 34.2657585144043, 34.234718322753906, 34.2943000793457, 34.20240020751953, 34.254066467285156, 34.282718658447266, 34.25194549560547, 34.27471923828125, 34.211448669433594, 34.224639892578125, 34.22967529296875], "compile_time": 4136.805525049567, "verification_time": 0, "benchmark_time": 1098.5578098334372, "GFLOP/s": 220.2371272831317, "strategy_time": 0, "framework_time": 2.304357010871172, "timestamp": "2023-12-21 11:09:15.972542+00:00"},
+"16,8,1,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.730442106723785, "times": [11.833869934082031, 11.775311470031738, 11.810510635375977, 11.772109985351562, 11.805391311645508, 11.71515941619873, 11.74155044555664, 11.746829986572266, 11.770990371704102, 11.74763011932373, 11.690348625183105, 11.738040924072266, 11.71051025390625, 11.785070419311523, 11.684748649597168, 11.659628868103027, 11.714348793029785, 11.72734546661377, 11.684269905090332, 11.731630325317383, 11.712909698486328, 11.75963020324707, 11.733550071716309, 11.733955383300781, 11.724909782409668, 11.68394947052002, 11.738030433654785, 11.67947006225586, 11.709710121154785, 11.660837173461914, 11.694510459899902, 11.697388648986816], "compile_time": 484.0430459007621, "verification_time": 0, "benchmark_time": 376.89910223707557, "GFLOP/s": 643.6029547149423, "strategy_time": 0, "framework_time": 1.424069982022047, "timestamp": "2023-12-21 11:09:16.834924+00:00"},
+"16,8,1,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 12.143920421600342, "times": [12.289874076843262, 12.243634223937988, 12.106674194335938, 11.955951690673828, 12.221235275268555, 12.193841934204102, 12.202033996582031, 12.159314155578613, 12.171314239501953, 12.192754745483398, 11.992753028869629, 12.157964706420898, 11.963472366333008, 12.0740327835083, 12.09691333770752, 12.167473793029785, 12.185553550720215, 12.013240814208984, 12.111312866210938, 12.222034454345703, 12.343316078186035, 12.287796020507812, 12.08603286743164, 12.318851470947266, 12.124753952026367, 11.977231979370117, 12.209553718566895, 12.019791603088379, 12.22171401977539, 12.10904598236084, 12.026191711425781, 12.159793853759766], "compile_time": 484.1856127604842, "verification_time": 0, "benchmark_time": 390.12023201212287, "GFLOP/s": 621.6894493619453, "strategy_time": 0, "framework_time": 1.3401373289525509, "timestamp": "2023-12-21 11:09:17.710586+00:00"},
+"16,8,1,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.389333963394165, "times": [7.426629066467285, 7.389029026031494, 7.379589080810547, 7.3802289962768555, 7.415588855743408, 7.38710880279541, 7.384708881378174, 7.37286901473999, 7.386900901794434, 7.36630916595459, 7.395269870758057, 7.371428966522217, 7.388868808746338, 7.385829925537109, 7.404388904571533, 7.395109176635742, 7.399428844451904, 7.3875322341918945, 7.375749111175537, 7.447750091552734, 7.370950222015381, 7.3771891593933105, 7.38870906829834, 7.3863091468811035, 7.381508827209473, 7.386949062347412, 7.38464879989624, 7.394309043884277, 7.375588893890381, 7.401508808135986, 7.383749008178711, 7.386949062347412], "compile_time": 800.5860731936991, "verification_time": 0, "benchmark_time": 238.08314884081483, "GFLOP/s": 1021.7087544561527, "strategy_time": 0, "framework_time": 1.317052636295557, "timestamp": "2023-12-21 11:09:18.750588+00:00"},
+"16,8,1,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.17904469370842, "times": [7.224387168884277, 7.158146858215332, 7.229507923126221, 7.14566707611084, 7.149666786193848, 7.236388206481934, 7.103906154632568, 7.155587196350098, 7.117106914520264, 7.197667121887207, 7.147107124328613, 7.186787128448486, 7.128867149353027, 7.16806697845459, 7.167108058929443, 7.190307140350342, 7.163106918334961, 7.168251991271973, 7.158307075500488, 7.248067855834961, 7.119266986846924, 7.146626949310303, 7.199427127838135, 7.2083868980407715, 7.177347183227539, 7.186946868896484, 7.181481838226318, 7.213666915893555, 7.165987014770508, 7.123746871948242, 7.407909870147705, 7.154626846313477], "compile_time": 623.6682389862835, "verification_time": 0, "benchmark_time": 231.18642903864384, "GFLOP/s": 1051.6367458495497, "strategy_time": 0, "framework_time": 1.3978490605950356, "timestamp": "2023-12-21 11:09:19.606856+00:00"},
+"16,8,1,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.366988018155098, "times": [7.403268814086914, 7.374309062957764, 7.339748859405518, 7.341669082641602, 7.375268936157227, 7.381508827209473, 7.330149173736572, 7.314949035644531, 7.3423171043396, 7.339909076690674, 7.408870220184326, 7.361508846282959, 7.384230136871338, 7.380068778991699, 7.3421478271484375, 7.405028820037842, 7.376548767089844, 7.389997959136963, 7.3691887855529785, 7.394790172576904, 7.396870136260986, 7.378788948059082, 7.315107822418213, 7.348389148712158, 7.329988956451416, 7.351268768310547, 7.399059772491455, 7.383588790893555, 7.371428966522217, 7.416069984436035, 7.351909160614014, 7.345667839050293], "compile_time": 634.5533691346645, "verification_time": 0, "benchmark_time": 237.46605217456818, "GFLOP/s": 1024.807856534382, "strategy_time": 0, "framework_time": 1.4316258020699024, "timestamp": "2023-12-21 11:09:20.480323+00:00"},
+"16,8,1,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.844341814517975, "times": [7.954793930053711, 7.852074146270752, 7.923593997955322, 7.920554161071777, 7.903113842010498, 7.9360737800598145, 7.81783390045166, 7.816432952880859, 7.811752796173096, 7.819753170013428, 7.82599401473999, 7.827753067016602, 7.837512969970703, 7.836234092712402, 7.825353145599365, 7.826786994934082, 7.873673915863037, 7.82839298248291, 7.826152801513672, 7.818634033203125, 7.820713043212891, 7.830953121185303, 7.814154148101807, 7.812808036804199, 7.815272808074951, 7.8144731521606445, 7.822153091430664, 7.858953952789307, 7.843273162841797, 7.845513820648193, 7.818633079528809, 7.839571952819824], "compile_time": 742.8747178055346, "verification_time": 0, "benchmark_time": 252.44875717908144, "GFLOP/s": 962.4449544035992, "strategy_time": 0, "framework_time": 1.482612919062376, "timestamp": "2023-12-21 11:09:21.477145+00:00"},
+"16,8,1,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.354937061667442, "times": [7.45798921585083, 7.347908020019531, 7.357348918914795, 7.314468860626221, 7.322787761688232, 7.384549140930176, 7.418950080871582, 7.569671154022217, 7.348818778991699, 7.3349480628967285, 7.3335089683532715, 7.335268020629883, 7.319268226623535, 7.339908123016357, 7.316708087921143, 7.347908020019531, 7.333827972412109, 7.371621131896973, 7.336548805236816, 7.321989059448242, 7.346949100494385, 7.3466291427612305, 7.393829822540283, 7.405350208282471, 7.318628787994385, 7.352549076080322, 7.342429161071777, 7.2973480224609375, 7.313988208770752, 7.293509006500244, 7.338149070739746, 7.394629955291748], "compile_time": 622.7838639169931, "verification_time": 0, "benchmark_time": 236.93534405902028, "GFLOP/s": 1026.4869891746418, "strategy_time": 0, "framework_time": 1.3774898834526539, "timestamp": "2023-12-21 11:09:22.338258+00:00"},
+"16,8,1,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.250574707984924, "times": [7.292548179626465, 7.255908012390137, 7.228547096252441, 7.2637481689453125, 7.200228214263916, 7.2525482177734375, 7.271907806396484, 7.263428211212158, 7.252893924713135, 7.249827861785889, 7.242948055267334, 7.243907928466797, 7.254787921905518, 7.248547077178955, 7.270788192749023, 7.238468170166016, 7.251267910003662, 7.282372951507568, 7.264227867126465, 7.253828048706055, 7.2487077713012695, 7.284388065338135, 7.276867866516113, 7.236708164215088, 7.259108066558838, 7.242787837982178, 7.242433071136475, 7.247107982635498, 7.201347827911377, 7.208868026733398, 7.251748085021973, 7.235588073730469], "compile_time": 628.7666419520974, "verification_time": 0, "benchmark_time": 233.74726437032223, "GFLOP/s": 1041.2619004788135, "strategy_time": 0, "framework_time": 1.3381224125623703, "timestamp": "2023-12-21 11:09:23.202125+00:00"},
+"16,8,2,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.738663166761398, "times": [5.754292964935303, 5.725654125213623, 5.715414047241211, 5.729973793029785, 5.740054130554199, 5.7083740234375, 5.7133331298828125, 5.721653938293457, 5.8054938316345215, 5.721494197845459, 5.714032173156738, 5.705492973327637, 5.803254127502441, 5.7336530685424805, 5.70261287689209, 5.707092761993408, 5.7008538246154785, 5.924536228179932, 5.805655002593994, 5.713014125823975, 5.78533411026001, 5.745575904846191, 5.721813201904297, 5.721494197845459, 5.725974082946777, 5.735894203186035, 5.7149338722229, 5.717973232269287, 5.722932815551758, 5.716853141784668, 5.7758941650390625, 5.706613063812256], "compile_time": 951.8241579644382, "verification_time": 0, "benchmark_time": 185.31742878258228, "GFLOP/s": 1315.593367411505, "strategy_time": 0, "framework_time": 1.4494303613901138, "timestamp": "2023-12-21 11:09:24.340732+00:00"},
+"16,8,2,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.488565146923065, "times": [9.542649269104004, 9.511129379272461, 9.509529113769531, 9.49384880065918, 9.489688873291016, 9.488728523254395, 9.485112190246582, 9.486968994140625, 9.482488632202148, 9.485368728637695, 9.481847763061523, 9.492889404296875, 9.485849380493164, 9.485594749450684, 9.484728813171387, 9.484728813171387, 9.482169151306152, 9.48360824584961, 9.485368728637695, 9.483609199523926, 9.488719940185547, 9.48344898223877, 9.482008934020996, 9.48344898223877, 9.483128547668457, 9.480408668518066, 9.481048583984375, 9.482410430908203, 9.489048957824707, 9.485849380493164, 9.48472785949707, 9.483928680419922], "compile_time": 426.6619300469756, "verification_time": 0, "benchmark_time": 305.2268298342824, "GFLOP/s": 795.6679522243907, "strategy_time": 0, "framework_time": 1.4191009104251862, "timestamp": "2023-12-21 11:09:25.074054+00:00"},
+"16,8,2,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.480731844902039, "times": [9.528568267822266, 9.494488716125488, 9.491289138793945, 9.482648849487305, 9.479289054870605, 9.474008560180664, 9.472375869750977, 9.47416877746582, 9.47304916381836, 9.470808029174805, 9.470808982849121, 9.470169067382812, 9.470488548278809, 9.469754219055176, 9.470169067382812, 9.471769332885742, 9.468888282775879, 9.46968936920166, 9.470808982849121, 9.471928596496582, 9.471955299377441, 9.46968936920166, 9.473849296569824, 9.472408294677734, 9.470488548278809, 9.472088813781738, 9.470487594604492, 9.650847434997559, 9.472249031066895, 9.471288681030273, 9.471129417419434, 9.471768379211426], "compile_time": 426.1759580112994, "verification_time": 0, "benchmark_time": 305.318889208138, "GFLOP/s": 796.3253600574766, "strategy_time": 0, "framework_time": 1.4245104975998402, "timestamp": "2023-12-21 11:09:25.806989+00:00"},
+"16,8,2,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7566514052450657, "times": [1.7921760082244873, 1.7641760110855103, 1.7665760517120361, 1.76145601272583, 1.762895941734314, 1.7571369409561157, 1.760336995124817, 1.7595360279083252, 1.7579360008239746, 1.7555370330810547, 1.7524969577789307, 1.7540969848632812, 1.7532960176467896, 1.754256010055542, 1.754256010055542, 1.752336025238037, 1.7540969848632812, 1.7502570152282715, 1.7542569637298584, 1.7524960041046143, 1.7529759407043457, 1.7505760192871094, 1.7528170347213745, 1.7536170482635498, 1.7510559558868408, 1.7592159509658813, 1.7540969848632812, 1.753777027130127, 1.753777027130127, 1.7536159753799438, 1.7524960041046143, 1.7552160024642944], "compile_time": 477.70719416439533, "verification_time": 0, "benchmark_time": 57.75528121739626, "GFLOP/s": 4297.80614267448, "strategy_time": 0, "framework_time": 1.3649668544530869, "timestamp": "2023-12-21 11:09:26.343832+00:00"},
+"16,8,2,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.486613392829895, "times": [9.531128883361816, 9.508249282836914, 9.510808944702148, 9.501049041748047, 9.489849090576172, 9.486648559570312, 9.487834930419922, 9.48616886138916, 9.482488632202148, 9.486167907714844, 9.482169151306152, 9.483928680419922, 9.48456859588623, 9.485644340515137, 9.479768753051758, 9.483609199523926, 9.482488632202148, 9.484889030456543, 9.482008934020996, 9.483128547668457, 9.483924865722656, 9.479289054870605, 9.480249404907227, 9.480568885803223, 9.480729103088379, 9.478328704833984, 9.47848892211914, 9.479896545410156, 9.482969284057617, 9.481369018554688, 9.481047630310059, 9.482169151306152], "compile_time": 421.73423804342747, "verification_time": 0, "benchmark_time": 305.21969590336084, "GFLOP/s": 795.8316511249627, "strategy_time": 0, "framework_time": 1.254362054169178, "timestamp": "2023-12-21 11:09:27.072055+00:00"},
+"16,8,2,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.480454087257385, "times": [9.525688171386719, 9.494009017944336, 9.484728813171387, 9.483287811279297, 9.688410758972168, 9.478328704833984, 9.472209930419922, 9.471769332885742, 9.470808982849121, 9.479289054870605, 9.470969200134277, 9.47000789642334, 9.474968910217285, 9.471162796020508, 9.46968936920166, 9.468889236450195, 9.469207763671875, 9.467768669128418, 9.467928886413574, 9.47000789642334, 9.469173431396484, 9.468568801879883, 9.472249031066895, 9.47000789642334, 9.468568801879883, 9.467609405517578, 9.467928886413574, 9.468778610229492, 9.468729019165039, 9.468408584594727, 9.467609405517578, 9.467767715454102], "compile_time": 420.46492686495185, "verification_time": 0, "benchmark_time": 305.32478960230947, "GFLOP/s": 796.3486907391456, "strategy_time": 0, "framework_time": 1.3936413452029228, "timestamp": "2023-12-21 11:09:27.799254+00:00"},
+"16,8,2,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.715865463018417, "times": [9.055124282836914, 8.731922149658203, 8.719442367553711, 8.718960762023926, 8.702961921691895, 8.706802368164062, 8.723921775817871, 8.697683334350586, 8.715921401977539, 8.686322212219238, 8.707121849060059, 8.743122100830078, 8.683921813964844, 8.697840690612793, 8.702642440795898, 8.706351280212402, 8.685200691223145, 8.74088191986084, 8.680400848388672, 8.70040225982666, 8.694961547851562, 8.70808219909668, 8.68680191040039, 8.68350887298584, 8.699920654296875, 8.698321342468262, 8.711601257324219, 8.690321922302246, 8.681840896606445, 8.688241004943848, 8.754961967468262, 8.70218276977539], "compile_time": 2340.6386766582727, "verification_time": 0, "benchmark_time": 280.5134220980108, "GFLOP/s": 866.2074044205617, "strategy_time": 0, "framework_time": 1.316612120717764, "timestamp": "2023-12-21 11:09:30.421738+00:00"},
+"16,8,2,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.248546048998833, "times": [7.2864670753479, 7.253828048706055, 7.245987892150879, 7.245508193969727, 7.25078821182251, 7.24486780166626, 7.238148212432861, 7.239108085632324, 7.23764705657959, 7.24102783203125, 7.239748001098633, 7.2375078201293945, 7.234306812286377, 7.2375078201293945, 7.445189952850342, 7.244227886199951, 7.240228176116943, 7.237668037414551, 7.2387871742248535, 7.247588157653809, 7.242467880249023, 7.235908031463623, 7.239587783813477, 7.237506866455078, 7.23494815826416, 7.248387813568115, 7.244349002838135, 7.236547946929932, 7.236067771911621, 7.23494815826416, 7.236227989196777, 7.240387916564941], "compile_time": 686.1804919317365, "verification_time": 0, "benchmark_time": 233.39714435860515, "GFLOP/s": 1041.5533196540523, "strategy_time": 0, "framework_time": 1.3947146944701672, "timestamp": "2023-12-21 11:09:31.342726+00:00"},
+"16,8,2,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.198666974902153, "times": [7.244707107543945, 7.216066837310791, 7.207746982574463, 7.203907012939453, 7.199747085571289, 7.198946952819824, 7.197667121887207, 7.1971869468688965, 7.196152210235596, 7.194626808166504, 7.2018280029296875, 7.195427894592285, 7.195908069610596, 7.193827152252197, 7.196066856384277, 7.209827899932861, 7.196387767791748, 7.193541049957275, 7.195908069610596, 7.196387767791748, 7.198147773742676, 7.194468021392822, 7.19430685043335, 7.195587158203125, 7.193187236785889, 7.193666934967041, 7.19753885269165, 7.191427230834961, 7.191906929016113, 7.191106796264648, 7.191586971282959, 7.192546844482422], "compile_time": 680.7305361144245, "verification_time": 0, "benchmark_time": 232.32522699981928, "GFLOP/s": 1048.7701718001226, "strategy_time": 0, "framework_time": 1.407017931342125, "timestamp": "2023-12-21 11:09:32.257204+00:00"},
+"16,8,2,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 4.5710277408361435, "times": [4.60820198059082, 4.562442779541016, 4.561963081359863, 4.589162826538086, 4.571242809295654, 4.579883098602295, 4.569162845611572, 4.553163051605225, 4.553483009338379, 4.557962894439697, 4.551242828369141, 4.5672430992126465, 4.561161994934082, 4.56189489364624, 4.560842037200928, 4.561962127685547, 4.558602809906006, 4.5560431480407715, 4.565803050994873, 4.572362899780273, 4.572843074798584, 4.549643039703369, 4.569803237915039, 4.572042942047119, 4.752523899078369, 4.5646820068359375, 4.558281898498535, 4.544428825378418, 4.565962791442871, 4.569003105163574, 4.55508279800415, 4.57476282119751], "compile_time": 773.3896118588746, "verification_time": 0, "benchmark_time": 147.61201478540897, "GFLOP/s": 1651.652019643832, "strategy_time": 0, "framework_time": 1.502523198723793, "timestamp": "2023-12-21 11:09:33.179724+00:00"},
+"16,8,2,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.240590155124664, "times": [7.282627105712891, 7.254148006439209, 7.249348163604736, 7.245188236236572, 7.246307849884033, 7.2394280433654785, 7.242308139801025, 7.242147922515869, 7.238840103149414, 7.242146968841553, 7.236547946929932, 7.235908031463623, 7.235908031463623, 7.233987808227539, 7.238306999206543, 7.23494815826416, 7.2464680671691895, 7.238032817840576, 7.233667850494385, 7.235588073730469, 7.235907077789307, 7.233187198638916, 7.233667850494385, 7.238947868347168, 7.241507053375244, 7.240067005157471, 7.2443671226501465, 7.241987228393555, 7.233508110046387, 7.233027935028076, 7.233828067779541, 7.237028121948242], "compile_time": 685.7558488845825, "verification_time": 0, "benchmark_time": 233.14283089712262, "GFLOP/s": 1042.697768863015, "strategy_time": 0, "framework_time": 1.3752048835158348, "timestamp": "2023-12-21 11:09:34.100014+00:00"},
+"16,8,2,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.197157129645348, "times": [7.242786884307861, 7.214306831359863, 7.208548069000244, 7.205028057098389, 7.203426837921143, 7.1992669105529785, 7.197987079620361, 7.196227073669434, 7.1933817863464355, 7.195426940917969, 7.193027019500732, 7.199428081512451, 7.192868232727051, 7.193027973175049, 7.201827049255371, 7.192226886749268, 7.191267013549805, 7.191103935241699, 7.189827919006348, 7.189348220825195, 7.189507007598877, 7.197987079620361, 7.193827152252197, 7.189826965332031, 7.194787979125977, 7.191906929016113, 7.192028999328613, 7.190307140350342, 7.194147109985352, 7.188547134399414, 7.204867839813232, 7.190948009490967], "compile_time": 674.663966987282, "verification_time": 0, "benchmark_time": 232.10379621014, "GFLOP/s": 1048.9901865421725, "strategy_time": 0, "framework_time": 1.4092116616666317, "timestamp": "2023-12-21 11:09:35.008207+00:00"},
+"16,8,2,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 32.63828778266907, "times": [32.65470504760742, 33.113380432128906, 33.06830978393555, 32.391056060791016, 32.498382568359375, 32.61317825317383, 32.760948181152344, 32.26618957519531, 32.4913444519043, 32.60063552856445, 32.790069580078125, 32.36418151855469, 32.70814514160156, 32.979270935058594, 32.612144470214844, 32.72849655151367, 32.65198516845703, 32.61158752441406, 32.4347038269043, 32.533668518066406, 32.40766525268555, 33.12882614135742, 32.3214225769043, 32.78749084472656, 32.776466369628906, 32.42231369018555, 32.691505432128906, 32.786216735839844, 32.459503173828125, 32.59485626220703, 32.58494567871094, 32.59161376953125], "compile_time": 1734.5602288842201, "verification_time": 0, "benchmark_time": 1046.2549682706594, "GFLOP/s": 231.3156636853026, "strategy_time": 0, "framework_time": 1.5543228946626186, "timestamp": "2023-12-21 11:09:37.790592+00:00"},
+"16,8,2,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.348419964313507, "times": [18.410892486572266, 18.37377166748047, 18.50225257873535, 18.454296112060547, 18.43537139892578, 18.27857208251953, 18.271852493286133, 18.352712631225586, 18.363691329956055, 18.473291397094727, 18.323211669921875, 18.269224166870117, 18.363372802734375, 18.3753719329834, 18.426891326904297, 18.30486488342285, 18.337772369384766, 18.353452682495117, 18.22401237487793, 18.396547317504883, 18.353931427001953, 18.45441246032715, 18.213769912719727, 18.27030372619629, 18.28529167175293, 18.307052612304688, 18.377771377563477, 18.247068405151367, 18.256332397460938, 18.3052921295166, 18.420011520385742, 18.366775512695312], "compile_time": 1005.6539559736848, "verification_time": 0, "benchmark_time": 588.6551039293408, "GFLOP/s": 411.4657945852433, "strategy_time": 0, "framework_time": 1.4669829979538918, "timestamp": "2023-12-21 11:09:39.386385+00:00"},
+"16,8,2,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.594008147716522, "times": [18.159528732299805, 18.054248809814453, 18.083690643310547, 18.040897369384766, 18.06224822998047, 18.16625213623047, 18.05744743347168, 18.276636123657227, 18.273452758789062, 18.111047744750977, 17.96464729309082, 32.3624153137207, 18.23105239868164, 18.180330276489258, 18.16176986694336, 18.0788516998291, 18.19824981689453, 18.28609275817871, 18.08688735961914, 18.149150848388672, 18.10896873474121, 18.19889259338379, 18.285612106323242, 18.120336532592773, 18.12289047241211, 17.94864845275879, 18.132810592651367, 18.284759521484375, 18.092327117919922, 18.317611694335938, 18.23569107055664, 18.174814224243164], "compile_time": 1001.5575918368995, "verification_time": 0, "benchmark_time": 596.5076261200011, "GFLOP/s": 406.03118703737704, "strategy_time": 0, "framework_time": 1.2721573002636433, "timestamp": "2023-12-21 11:09:40.985738+00:00"},
+"16,8,2,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 31.837188720703125, "times": [31.763015747070312, 31.873964309692383, 31.887500762939453, 31.77462387084961, 31.58349609375, 32.04938507080078, 32.31614303588867, 31.6472110748291, 31.9964599609375, 31.544042587280273, 31.651336669921875, 31.86371612548828, 32.00782012939453, 31.97842788696289, 31.7246150970459, 31.63222312927246, 31.752775192260742, 31.844039916992188, 31.93821907043457, 31.906980514526367, 31.850217819213867, 31.614042282104492, 32.496463775634766, 31.653772354125977, 31.77293586730957, 31.929611206054688, 31.567495346069336, 31.972400665283203, 31.83037757873535, 31.917911529541016, 31.65581512451172, 31.792999267578125], "compile_time": 1950.6469331681728, "verification_time": 0, "benchmark_time": 1020.3531687147915, "GFLOP/s": 237.13611356302138, "strategy_time": 0, "framework_time": 1.5053772367537022, "timestamp": "2023-12-21 11:09:43.958259+00:00"},
+"16,8,2,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.276902616024017, "times": [18.340492248535156, 18.28289222717285, 18.275211334228516, 18.154081344604492, 18.27665138244629, 18.260652542114258, 18.270092010498047, 18.425264358520508, 18.230571746826172, 18.326091766357422, 18.271371841430664, 18.35599708557129, 18.246572494506836, 18.286251068115234, 18.23969268798828, 18.27798080444336, 18.247852325439453, 18.353771209716797, 18.34033203125, 18.266496658325195, 18.347532272338867, 18.293132781982422, 18.294252395629883, 18.299467086791992, 18.194570541381836, 18.187049865722656, 18.241931915283203, 18.265979766845703, 18.254732131958008, 18.236492156982422, 18.234411239624023, 18.28301239013672], "compile_time": 1017.9203427396715, "verification_time": 0, "benchmark_time": 586.4691049791873, "GFLOP/s": 413.07585637518605, "strategy_time": 0, "framework_time": 1.3959151692688465, "timestamp": "2023-12-21 11:09:45.564060+00:00"},
+"16,8,2,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 18.038168132305145, "times": [18.0684871673584, 18.079208374023438, 18.080488204956055, 18.030479431152344, 18.162729263305664, 18.082250595092773, 18.145130157470703, 18.00301170349121, 17.936168670654297, 18.084327697753906, 17.952167510986328, 18.057811737060547, 18.019847869873047, 17.935688018798828, 18.075050354003906, 18.190793991088867, 17.96112823486328, 18.062408447265625, 18.149450302124023, 18.20353126525879, 17.923847198486328, 17.9654483795166, 18.04880714416504, 17.889921188354492, 18.01968765258789, 17.996328353881836, 17.964487075805664, 18.129941940307617, 17.911527633666992, 17.996807098388672, 18.107210159301758, 17.987207412719727], "compile_time": 995.9719250909984, "verification_time": 0, "benchmark_time": 578.8477910682559, "GFLOP/s": 418.5428999566153, "strategy_time": 0, "framework_time": 1.4418559148907661, "timestamp": "2023-12-21 11:09:47.140338+00:00"},
+"16,8,2,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.135812923312187, "times": [6.1925368309021, 6.138776779174805, 6.116696834564209, 6.1374969482421875, 6.130456924438477, 6.146137237548828, 6.13621711730957, 6.159418106079102, 6.125176906585693, 6.1472578048706055, 6.127277851104736, 6.1243767738342285, 6.115897178649902, 6.138617038726807, 6.158297061920166, 6.166937828063965, 6.140538215637207, 6.137338161468506, 6.143898010253906, 6.103736877441406, 6.123096942901611, 6.107254981994629, 6.146297931671143, 6.157496929168701, 6.125017166137695, 6.120697021484375, 6.14533805847168, 6.109817981719971, 6.1360578536987305, 6.150937080383301, 6.101497173309326, 6.135417938232422], "compile_time": 1077.922930009663, "verification_time": 0, "benchmark_time": 198.01278598606586, "GFLOP/s": 1230.4396001572607, "strategy_time": 0, "framework_time": 1.3055307790637016, "timestamp": "2023-12-21 11:09:48.417595+00:00"},
+"16,8,2,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.941182225942612, "times": [9.106485366821289, 9.104565620422363, 8.942804336547852, 8.90040397644043, 8.919763565063477, 8.887924194335938, 8.973057746887207, 8.888083457946777, 8.852723121643066, 8.965523719787598, 9.021844863891602, 8.91832447052002, 8.919763565063477, 8.94440746307373, 8.96312427520752, 8.868403434753418, 8.88520336151123, 8.932563781738281, 8.981683731079102, 8.841201782226562, 8.878230094909668, 8.87336254119873, 8.929363250732422, 9.130485534667969, 8.905524253845215, 8.927284240722656, 9.057365417480469, 8.907946586608887, 8.873682975769043, 8.83800220489502, 9.050643920898438, 8.928084373474121], "compile_time": 1364.8143112659454, "verification_time": 0, "benchmark_time": 287.8163936547935, "GFLOP/s": 844.3790775334609, "strategy_time": 0, "framework_time": 1.440201885998249, "timestamp": "2023-12-21 11:09:50.071681+00:00"},
+"16,8,2,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.889193147420883, "times": [8.985363006591797, 8.961044311523438, 8.918482780456543, 8.92984390258789, 8.951924324035645, 8.926484107971191, 8.978546142578125, 8.96744441986084, 8.888723373413086, 8.841683387756348, 8.846643447875977, 8.864242553710938, 8.853042602539062, 8.864242553710938, 8.821733474731445, 8.88536262512207, 8.87928295135498, 8.863603591918945, 8.926644325256348, 8.851922988891602, 8.841362953186035, 8.936229705810547, 8.927603721618652, 8.950803756713867, 8.911763191223145, 8.80504322052002, 8.817361831665039, 8.852883338928223, 8.78872299194336, 8.869099617004395, 8.898162841796875, 8.848882675170898], "compile_time": 1507.5870426371694, "verification_time": 0, "benchmark_time": 286.11732088029385, "GFLOP/s": 849.3174886396173, "strategy_time": 0, "framework_time": 1.4693178236484528, "timestamp": "2023-12-21 11:09:51.866871+00:00"},
+"16,8,2,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.832625061273575, "times": [12.08187198638916, 11.803951263427734, 11.771791458129883, 11.80155086517334, 11.838191032409668, 11.880276679992676, 11.789230346679688, 11.863791465759277, 11.854670524597168, 11.810990333557129, 11.785229682922363, 11.781407356262207, 11.78523063659668, 11.845391273498535, 11.817390441894531, 11.848430633544922, 11.777230262756348, 11.79796314239502, 11.809070587158203, 11.788270950317383, 11.778349876403809, 11.855951309204102, 11.734829902648926, 11.791924476623535, 11.746509552001953, 11.897871017456055, 11.823789596557617, 11.847631454467773, 11.847311019897461, 11.83167839050293, 12.034032821655273, 11.922191619873047], "compile_time": 1542.4895817413926, "verification_time": 0, "benchmark_time": 380.1542459987104, "GFLOP/s": 638.0449951641924, "strategy_time": 0, "framework_time": 1.4577661640942097, "timestamp": "2023-12-21 11:09:53.790988+00:00"},
+"16,8,2,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.960090637207031, "times": [9.017683982849121, 9.035605430603027, 8.937203407287598, 8.987764358520508, 8.972244262695312, 9.014484405517578, 8.996382713317871, 9.012724876403809, 9.047764778137207, 8.971923828125, 9.014643669128418, 8.957843780517578, 8.888083457946777, 8.942950248718262, 9.011605262756348, 8.975923538208008, 8.981683731079102, 8.822961807250977, 8.910483360290527, 8.970004081726074, 8.91166877746582, 8.887763023376465, 8.889524459838867, 9.019285202026367, 8.944724082946777, 8.976083755493164, 8.94088363647461, 8.971147537231445, 8.941683769226074, 8.849682807922363, 8.913043975830078, 9.007444381713867], "compile_time": 1366.6771431453526, "verification_time": 0, "benchmark_time": 288.24670892208815, "GFLOP/s": 842.5971907749973, "strategy_time": 0, "framework_time": 1.398209948092699, "timestamp": "2023-12-21 11:09:55.447326+00:00"},
+"16,8,2,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 8.885046988725662, "times": [8.940563201904297, 8.866003036499023, 8.90152359008789, 8.945043563842773, 8.865363121032715, 8.886163711547852, 8.819164276123047, 8.93640422821045, 8.840402603149414, 8.857843399047852, 8.913203239440918, 8.860563278198242, 8.866003036499023, 8.85592269897461, 8.86184310913086, 8.842002868652344, 8.858802795410156, 8.899763107299805, 8.844243049621582, 8.918804168701172, 8.88856315612793, 8.91015338897705, 8.880402565002441, 8.95992374420166, 8.849042892456055, 8.926484107971191, 8.903923988342285, 8.888084411621094, 8.873608589172363, 8.830323219299316, 8.887123107910156, 8.944244384765625], "compile_time": 1495.333037339151, "verification_time": 0, "benchmark_time": 285.8898304402828, "GFLOP/s": 849.7138180113127, "strategy_time": 0, "framework_time": 1.34358461946249, "timestamp": "2023-12-21 11:09:57.229908+00:00"},
+"16,8,3,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.475544571876526, "times": [33.59743118286133, 33.347835540771484, 33.60063552856445, 33.538272857666016, 33.29247283935547, 33.751407623291016, 33.33407211303711, 33.59074783325195, 33.52863311767578, 33.59748077392578, 33.518714904785156, 33.41576385498047, 33.37535095214844, 33.25873565673828, 33.3739128112793, 33.29057312011719, 33.39903259277344, 33.477176666259766, 33.493595123291016, 33.61182403564453, 33.511512756347656, 33.397071838378906, 33.614715576171875, 33.45940017700195, 33.359031677246094, 33.68442916870117, 33.56767654418945, 33.54410171508789, 33.27647018432617, 33.602073669433594, 33.475833892822266, 33.33143997192383], "compile_time": 2392.872836906463, "verification_time": 0, "benchmark_time": 1073.0000659823418, "GFLOP/s": 225.53022800837996, "strategy_time": 0, "framework_time": 1.3970490545034409, "timestamp": "2023-12-21 11:10:00.697200+00:00"},
+"16,8,3,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.20780834555626, "times": [15.329422950744629, 15.182703018188477, 15.25998306274414, 15.311983108520508, 15.168258666992188, 15.211181640625, 15.295823097229004, 15.207661628723145, 15.206542015075684, 15.145821571350098, 15.169261932373047, 15.13822078704834, 15.144782066345215, 15.157261848449707, 15.207880020141602, 15.21246337890625, 15.259182929992676, 15.261423110961914, 15.107661247253418, 15.182488441467285, 15.242222785949707, 15.250062942504883, 15.247822761535645, 15.307024002075195, 15.124080657958984, 15.160781860351562, 15.246062278747559, 15.218221664428711, 15.14718246459961, 15.174915313720703, 15.211181640625, 15.16030216217041], "compile_time": 552.4957370944321, "verification_time": 0, "benchmark_time": 488.3117531426251, "GFLOP/s": 496.43887064147845, "strategy_time": 0, "framework_time": 1.5069707296788692, "timestamp": "2023-12-21 11:10:01.739530+00:00"},
+"16,8,3,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.1446992456913, "times": [15.058380126953125, 15.134542465209961, 15.247182846069336, 15.06766128540039, 15.155159950256348, 15.038061141967773, 15.159662246704102, 15.13486099243164, 15.171502113342285, 15.080595016479492, 15.052141189575195, 15.185103416442871, 15.036460876464844, 15.422863960266113, 15.200904846191406, 15.306702613830566, 15.14398193359375, 15.057101249694824, 14.983819961547852, 15.112764358520508, 15.111660957336426, 15.287022590637207, 15.16366195678711, 15.160942077636719, 15.302021026611328, 15.076460838317871, 15.156621932983398, 15.095662117004395, 15.109742164611816, 15.114925384521484, 15.122700691223145, 15.1795015335083], "compile_time": 551.3594639487565, "verification_time": 0, "benchmark_time": 486.1624278128147, "GFLOP/s": 498.50756872229863, "strategy_time": 0, "framework_time": 1.3931202702224255, "timestamp": "2023-12-21 11:10:02.778461+00:00"},
+"16,8,3,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.32566463947296, "times": [33.37791061401367, 33.27201843261719, 33.495994567871094, 33.29996109008789, 33.47087478637695, 33.10464096069336, 33.18415069580078, 33.103904724121094, 33.28703308105469, 33.42698669433594, 33.46095275878906, 33.43706512451172, 33.46703338623047, 33.38084411621094, 33.237430572509766, 33.37820816040039, 33.200950622558594, 33.5930061340332, 33.29903030395508, 33.344703674316406, 33.38431167602539, 33.38956832885742, 33.234073638916016, 33.17147445678711, 33.150390625, 33.24540328979492, 33.297271728515625, 33.477901458740234, 33.55183410644531, 33.263916015625, 33.333431243896484, 33.09899139404297], "compile_time": 4683.965457603335, "verification_time": 0, "benchmark_time": 1068.0338302627206, "GFLOP/s": 226.5445350205444, "strategy_time": 0, "framework_time": 1.3231351040303707, "timestamp": "2023-12-21 11:10:08.531799+00:00"},
+"16,8,3,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.350013703107834, "times": [15.227022171020508, 15.384305000305176, 15.110221862792969, 15.505425453186035, 15.309866905212402, 15.39038372039795, 15.370863914489746, 15.31070327758789, 15.393263816833496, 15.46295166015625, 15.399663925170898, 15.389424324035645, 15.333264350891113, 15.357904434204102, 15.206276893615723, 15.31390380859375, 15.426705360412598, 15.415504455566406, 15.243183135986328, 15.468538284301758, 15.378064155578613, 15.449584007263184, 15.388303756713867, 15.381903648376465, 15.35840892791748, 15.285582542419434, 15.208462715148926, 15.331502914428711, 15.354384422302246, 15.216575622558594, 15.391983985900879, 15.436305046081543], "compile_time": 548.2892720028758, "verification_time": 0, "benchmark_time": 492.9305771365762, "GFLOP/s": 491.83976939847577, "strategy_time": 0, "framework_time": 1.491390634328127, "timestamp": "2023-12-21 11:10:09.574526+00:00"},
+"16,8,3,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.158821791410446, "times": [15.21550178527832, 15.091981887817383, 15.118541717529297, 15.193902969360352, 15.225714683532715, 15.088300704956055, 15.086860656738281, 15.238862037658691, 15.071181297302246, 15.168574333190918, 15.101421356201172, 15.023981094360352, 15.151501655578613, 14.999659538269043, 15.22006893157959, 15.108461380004883, 15.228623390197754, 15.155342102050781, 15.188141822814941, 15.057292938232422, 15.129582405090332, 15.330063819885254, 15.271344184875488, 15.300304412841797, 15.216100692749023, 15.097901344299316, 15.171022415161133, 15.228623390197754, 15.246382713317871, 15.07341194152832, 15.10798168182373, 15.17566204071045], "compile_time": 547.7200681343675, "verification_time": 0, "benchmark_time": 486.79007310420275, "GFLOP/s": 498.04313975628156, "strategy_time": 0, "framework_time": 1.4015077613294125, "timestamp": "2023-12-21 11:10:10.610453+00:00"},
+"16,8,3,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 32.72901630401611, "times": [32.780948638916016, 32.86962890625, 32.694068908691406, 32.930694580078125, 32.55070495605469, 32.80607986450195, 32.95486831665039, 32.817710876464844, 32.30014419555664, 33.07231903076172, 33.24767303466797, 32.345333099365234, 32.87534713745117, 33.068050384521484, 32.60718536376953, 32.461727142333984, 32.642066955566406, 32.93360900878906, 33.1905517578125, 32.37979507446289, 32.59998321533203, 32.622894287109375, 32.58158493041992, 32.404808044433594, 32.527503967285156, 32.83681106567383, 32.639347076416016, 32.387794494628906, 32.867347717285156, 33.17123031616211, 32.71038818359375, 32.450321197509766], "compile_time": 1669.2681079730392, "verification_time": 0, "benchmark_time": 1048.9006689749658, "GFLOP/s": 230.67443059917403, "strategy_time": 0, "framework_time": 1.4851400628685951, "timestamp": "2023-12-21 11:10:13.330122+00:00"},
+"16,8,3,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.3760244846344, "times": [20.42019271850586, 20.423871994018555, 20.250749588012695, 20.353103637695312, 20.3984317779541, 20.34259033203125, 20.34307289123535, 20.342899322509766, 20.399871826171875, 20.63395118713379, 20.57219123840332, 20.392333984375, 20.368831634521484, 20.340511322021484, 20.495872497558594, 20.211328506469727, 20.318431854248047, 20.402751922607422, 20.36419105529785, 20.434656143188477, 20.31635284423828, 20.294910430908203, 20.271230697631836, 20.587799072265625, 20.366432189941406, 20.37171173095703, 20.22579002380371, 20.28394889831543, 20.316509246826172, 20.299230575561523, 20.440671920776367, 20.448360443115234], "compile_time": 1040.797170251608, "verification_time": 0, "benchmark_time": 653.6817098967731, "GFLOP/s": 370.521109537009, "strategy_time": 0, "framework_time": 1.4469246380031109, "timestamp": "2023-12-21 11:10:15.026063+00:00"},
+"16,8,3,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.730153501033783, "times": [19.80802345275879, 19.744823455810547, 19.744504928588867, 19.672168731689453, 19.669784545898438, 19.619863510131836, 19.76082420349121, 19.735218048095703, 19.669944763183594, 19.70098304748535, 19.758745193481445, 19.780311584472656, 19.695863723754883, 19.670583724975586, 19.799705505371094, 19.6951847076416, 19.848665237426758, 19.777624130249023, 19.611543655395508, 19.74414825439453, 19.774423599243164, 19.723703384399414, 19.75730323791504, 19.754295349121094, 19.84194564819336, 19.68546485900879, 19.756826400756836, 19.685571670532227, 19.712663650512695, 19.640663146972656, 19.753463745117188, 19.77007293701172], "compile_time": 1059.9756692536175, "verification_time": 0, "benchmark_time": 632.9627558588982, "GFLOP/s": 382.6502008514238, "strategy_time": 0, "framework_time": 1.3824999332427979, "timestamp": "2023-12-21 11:10:16.720401+00:00"},
+"16,8,3,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 32.22126650810242, "times": [32.87406921386719, 31.908203125, 32.31550216674805, 31.882848739624023, 32.006221771240234, 32.563140869140625, 32.09326171875, 31.982667922973633, 32.602386474609375, 32.47932815551758, 32.503822326660156, 32.00770950317383, 32.22334289550781, 32.098148345947266, 31.9867000579834, 32.03786849975586, 31.895660400390625, 31.9829044342041, 32.35838317871094, 32.22088623046875, 32.16990280151367, 32.23046875, 32.685585021972656, 32.02310562133789, 32.048301696777344, 32.26247787475586, 32.04798126220703, 32.5507926940918, 32.226383209228516, 32.500213623046875, 32.25950241088867, 32.052757263183594], "compile_time": 1865.7169416546822, "verification_time": 0, "benchmark_time": 1032.6150888577104, "GFLOP/s": 234.3094489504789, "strategy_time": 0, "framework_time": 1.379154622554779, "timestamp": "2023-12-21 11:10:19.620126+00:00"},
+"16,8,3,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.172893404960632, "times": [20.223068237304688, 20.163867950439453, 20.171388626098633, 20.294788360595703, 20.174747467041016, 20.055707931518555, 20.13682746887207, 20.328306198120117, 20.0653076171875, 20.010108947753906, 20.112667083740234, 20.206228256225586, 20.337472915649414, 20.159387588500977, 19.956188201904297, 20.081104278564453, 20.28706932067871, 20.037948608398438, 20.139707565307617, 20.03462028503418, 20.121788024902344, 20.158428192138672, 20.235069274902344, 20.138303756713867, 20.25251007080078, 20.239389419555664, 20.494112014770508, 20.270376205444336, 20.292509078979492, 20.111547470092773, 20.064668655395508, 20.1773738861084], "compile_time": 1025.5360160954297, "verification_time": 0, "benchmark_time": 647.05595606938, "GFLOP/s": 374.25207422865145, "strategy_time": 0, "framework_time": 1.5315278433263302, "timestamp": "2023-12-21 11:10:21.294265+00:00"},
+"16,8,3,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 19.703346729278564, "times": [19.89970588684082, 19.751066207885742, 19.681623458862305, 19.6663875579834, 19.68498420715332, 19.62834358215332, 19.709623336791992, 19.632047653198242, 19.77570343017578, 19.699384689331055, 19.680984497070312, 19.675397872924805, 19.786745071411133, 19.62482452392578, 19.876028060913086, 19.75092315673828, 19.734264373779297, 19.6873836517334, 19.727706909179688, 19.681217193603516, 19.62322425842285, 19.763866424560547, 19.66530418395996, 19.689775466918945, 19.663223266601562, 19.68226432800293, 19.662424087524414, 19.717819213867188, 19.743703842163086, 19.617143630981445, 19.63202476501465, 19.69197654724121], "compile_time": 1053.4492768347263, "verification_time": 0, "benchmark_time": 632.1144723333418, "GFLOP/s": 383.17080360674504, "strategy_time": 0, "framework_time": 1.551907043904066, "timestamp": "2023-12-21 11:10:22.981397+00:00"},
+"16,8,3,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.976956605911255, "times": [41.55494689941406, 41.336910247802734, 41.145023345947266, 40.65415954589844, 41.25558853149414, 41.494590759277344, 41.1104621887207, 41.308837890625, 40.65782165527344, 40.628570556640625, 40.74166488647461, 40.8106689453125, 40.89494323730469, 40.482505798339844, 41.28278732299805, 40.779823303222656, 41.21894836425781, 41.41838455200195, 40.83270263671875, 40.85859680175781, 41.09494400024414, 41.26762390136719, 41.035743713378906, 40.716094970703125, 40.851585388183594, 40.46249771118164, 40.91990280151367, 41.3090705871582, 40.359256744384766, 40.57497024536133, 41.13622283935547, 41.0667610168457], "compile_time": 2613.205381203443, "verification_time": 0, "benchmark_time": 1312.7771951258183, "GFLOP/s": 184.2437268489307, "strategy_time": 0, "framework_time": 1.342992763966322, "timestamp": "2023-12-21 11:10:26.908738+00:00"},
+"16,8,3,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.610240042209625, "times": [20.902915954589844, 20.659713745117188, 20.541311264038086, 20.640884399414062, 20.608192443847656, 20.598112106323242, 20.578432083129883, 20.555776596069336, 20.500991821289062, 20.570432662963867, 20.591392517089844, 20.625539779663086, 20.6312313079834, 20.656354904174805, 20.56915283203125, 20.63160514831543, 20.576831817626953, 20.743236541748047, 20.523712158203125, 20.557035446166992, 20.557472229003906, 20.581472396850586, 20.612354278564453, 20.744808197021484, 20.74547576904297, 20.534591674804688, 20.45155143737793, 20.690547943115234, 20.635072708129883, 20.547231674194336, 20.547712326049805, 20.616535186767578], "compile_time": 1782.4686630629003, "verification_time": 0, "benchmark_time": 661.0723878256977, "GFLOP/s": 366.31049345073956, "strategy_time": 0, "framework_time": 1.3703051954507828, "timestamp": "2023-12-21 11:10:29.353665+00:00"},
+"16,8,3,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 20.963090777397156, "times": [21.016515731811523, 20.93219566345215, 20.96076011657715, 20.901796340942383, 20.931716918945312, 20.95597267150879, 20.947235107421875, 20.90227508544922, 20.9813232421875, 20.936996459960938, 20.945955276489258, 20.973331451416016, 20.936355590820312, 20.96595573425293, 20.94009780883789, 20.8912353515625, 20.99539566040039, 20.936723709106445, 20.973155975341797, 21.0142765045166, 20.968862533569336, 20.889476776123047, 21.002277374267578, 20.95825958251953, 21.016515731811523, 20.923076629638672, 21.03374481201172, 20.96755599975586, 20.924835205078125, 21.038955688476562, 21.036195755004883, 21.019878387451172], "compile_time": 1794.7210744023323, "verification_time": 0, "benchmark_time": 672.3080379888415, "GFLOP/s": 360.14475537835744, "strategy_time": 0, "framework_time": 1.3574408367276192, "timestamp": "2023-12-21 11:10:31.822066+00:00"},
+"16,8,3,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 40.72214674949646, "times": [41.102783203125, 40.73942184448242, 41.62071228027344, 40.627201080322266, 41.18182373046875, 40.57209014892578, 41.15078353881836, 40.48060989379883, 40.57014083862305, 40.58692169189453, 41.3112678527832, 40.380924224853516, 40.46854019165039, 39.825984954833984, 40.68278503417969, 40.12290954589844, 41.014625549316406, 40.68302536010742, 40.623741149902344, 40.88412094116211, 40.69926452636719, 41.04631042480469, 40.71574401855469, 40.438968658447266, 40.51845932006836, 40.90738296508789, 40.72198486328125, 40.19134521484375, 41.12790298461914, 40.654296875, 41.08358383178711, 40.37303924560547], "compile_time": 3216.3596809841692, "verification_time": 0, "benchmark_time": 1304.6916709281504, "GFLOP/s": 185.3965913546381, "strategy_time": 0, "framework_time": 1.4840266667306423, "timestamp": "2023-12-21 11:10:36.344617+00:00"},
+"16,8,3,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.024249255657196, "times": [21.388519287109375, 20.993635177612305, 21.053224563598633, 21.022916793823242, 21.022275924682617, 20.94843292236328, 21.02611541748047, 21.016355514526367, 20.945159912109375, 20.93299674987793, 21.090757369995117, 21.000703811645508, 21.01827621459961, 21.040035247802734, 21.001163482666016, 20.980356216430664, 20.97779655456543, 21.04554557800293, 21.001476287841797, 21.03395652770996, 21.009550094604492, 21.04307746887207, 20.959875106811523, 20.916461944580078, 20.989316940307617, 21.130279541015625, 21.02583122253418, 20.977476119995117, 21.04547882080078, 21.023815155029297, 21.001155853271484, 21.11395835876465], "compile_time": 1818.0745360441506, "verification_time": 0, "benchmark_time": 674.3720388039947, "GFLOP/s": 359.09711249111626, "strategy_time": 0, "framework_time": 1.7239120788872242, "timestamp": "2023-12-21 11:10:38.838803+00:00"},
+"16,8,3,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.459372520446777, "times": [21.580041885375977, 21.436359405517578, 21.473148345947266, 21.41204071044922, 21.464841842651367, 21.440603256225586, 21.528682708740234, 21.43939971923828, 21.42681121826172, 21.514122009277344, 21.511722564697266, 21.430912017822266, 21.419719696044922, 21.44868278503418, 21.455354690551758, 21.373319625854492, 21.5045223236084, 21.422311782836914, 21.44883918762207, 21.476682662963867, 21.445741653442383, 21.444360733032227, 21.44611930847168, 21.430143356323242, 21.48708152770996, 21.43347930908203, 21.510576248168945, 21.416519165039062, 21.444520950317383, 21.47365951538086, 21.467559814453125, 21.492040634155273], "compile_time": 1826.3306799344718, "verification_time": 0, "benchmark_time": 688.2990673184395, "GFLOP/s": 351.81584143741856, "strategy_time": 0, "framework_time": 1.3511497527360916, "timestamp": "2023-12-21 11:10:41.354799+00:00"},
+"16,8,3,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.63936507701874, "times": [44.10249328613281, 43.61604690551758, 43.54936981201172, 43.42270278930664, 43.64760971069336, 43.559326171875, 43.7191276550293, 43.307350158691406, 43.65416717529297, 43.36751937866211, 43.320247650146484, 43.66987991333008, 43.26136779785156, 43.81386947631836, 43.19656753540039, 43.55940628051758, 43.9935302734375, 43.1822395324707, 43.903133392333984, 43.52778244018555, 43.70808792114258, 43.84009552001953, 43.809532165527344, 43.83814239501953, 43.519927978515625, 43.56998825073242, 43.799293518066406, 43.71858215332031, 43.745853424072266, 43.86697769165039, 44.14361572265625, 43.525848388671875], "compile_time": 1792.5561862066388, "verification_time": 0, "benchmark_time": 1398.2002516277134, "GFLOP/s": 173.00314032240195, "strategy_time": 0, "framework_time": 1.431905198842287, "timestamp": "2023-12-21 11:10:44.547002+00:00"},
+"16,8,3,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.668536096811295, "times": [11.823630332946777, 11.614189147949219, 11.744111061096191, 11.626829147338867, 11.655308723449707, 11.593441009521484, 11.635788917541504, 11.660750389099121, 11.620908737182617, 11.65994930267334, 11.658510208129883, 11.611676216125488, 11.649548530578613, 11.706830024719238, 11.719949722290039, 11.69851016998291, 11.709870338439941, 11.644455909729004, 11.626668930053711, 11.818990707397461, 11.69690990447998, 11.661389350891113, 11.685229301452637, 11.6238374710083, 11.68986988067627, 11.686670303344727, 11.70890998840332, 11.663949966430664, 11.644268989562988, 11.61870288848877, 11.612269401550293, 11.621230125427246], "compile_time": 942.3480615951121, "verification_time": 0, "benchmark_time": 374.9844916164875, "GFLOP/s": 647.0175125106865, "strategy_time": 0, "framework_time": 1.443860586732626, "timestamp": "2023-12-21 11:10:45.865794+00:00"},
+"16,8,3,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.563701868057251, "times": [7.913834095001221, 7.566151142120361, 7.557510852813721, 7.555110931396484, 7.547591209411621, 7.546949863433838, 7.545510768890381, 7.547430992126465, 7.539715766906738, 7.551910877227783, 7.543591022491455, 7.54823112487793, 7.545670986175537, 7.539269924163818, 7.546630859375, 7.7514328956604, 7.544869899749756, 7.545024871826172, 7.543591022491455, 7.543271064758301, 7.545190811157227, 7.545670986175537, 7.545510768890381, 7.544711112976074, 7.544230937957764, 7.541830062866211, 7.542059898376465, 7.54279088973999, 7.54055118560791, 7.5400710105896, 7.537671089172363, 7.544870853424072], "compile_time": 913.8321620412171, "verification_time": 0, "benchmark_time": 243.85754391551018, "GFLOP/s": 998.1550478455287, "strategy_time": 0, "framework_time": 1.361028291285038, "timestamp": "2023-12-21 11:10:47.024860+00:00"},
+"16,8,3,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 43.61159408092499, "times": [44.057373046875, 43.99039840698242, 43.34632873535156, 43.66819763183594, 43.1541633605957, 43.84077072143555, 43.73977279663086, 43.22936248779297, 43.21304702758789, 43.536468505859375, 43.22968673706055, 43.86111831665039, 43.718971252441406, 43.694881439208984, 43.84169387817383, 43.5552864074707, 43.55208969116211, 43.62812805175781, 44.05961608886719, 43.55872344970703, 43.48312759399414, 43.65424346923828, 43.6444091796875, 43.92704391479492, 44.40857696533203, 43.59622573852539, 43.480247497558594, 43.329776763916016, 43.37576675415039, 43.453399658203125, 43.588409423828125, 43.15370559692383], "compile_time": 2237.3458398506045, "verification_time": 0, "benchmark_time": 1397.0679068006575, "GFLOP/s": 173.11330528278347, "strategy_time": 0, "framework_time": 1.394032035022974, "timestamp": "2023-12-21 11:10:50.660685+00:00"},
+"16,8,3,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.997206538915634, "times": [12.063793182373047, 12.023472785949707, 12.014352798461914, 11.985712051391602, 11.987471580505371, 11.903614044189453, 11.942031860351562, 11.902031898498535, 11.931471824645996, 11.998353004455566, 12.031473159790039, 12.00184154510498, 11.991633415222168, 11.992273330688477, 11.959152221679688, 11.981712341308594, 11.959792137145996, 12.059444427490234, 12.03531265258789, 12.06507396697998, 12.006512641906738, 12.001232147216797, 12.00267219543457, 12.027013778686523, 12.178513526916504, 12.044753074645996, 12.021073341369629, 11.976752281188965, 11.985392570495605, 11.95053482055664, 12.006032943725586, 11.880111694335938], "compile_time": 946.6415047645569, "verification_time": 0, "benchmark_time": 385.5070797726512, "GFLOP/s": 629.2920919141218, "strategy_time": 0, "framework_time": 1.470982562750578, "timestamp": "2023-12-21 11:10:51.994318+00:00"},
+"16,8,3,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 3, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.548700377345085, "times": [7.7479119300842285, 7.557671070098877, 7.551111221313477, 7.5471110343933105, 7.5429511070251465, 7.544550895690918, 7.541831016540527, 7.5410308837890625, 7.540791988372803, 7.540710926055908, 7.546791076660156, 7.5389509201049805, 7.539590835571289, 7.551431179046631, 7.539111137390137, 7.543430805206299, 7.540070056915283, 7.542588233947754, 7.541191101074219, 7.539590835571289, 7.536870956420898, 7.538630962371826, 7.536390781402588, 7.541350841522217, 7.537190914154053, 7.544069766998291, 7.546417236328125, 7.543270111083984, 7.537830829620361, 7.537830829620361, 7.540229797363281, 7.539910793304443], "compile_time": 916.3321503438056, "verification_time": 0, "benchmark_time": 243.3504299260676, "GFLOP/s": 1000.1386758783083, "strategy_time": 0, "framework_time": 1.3773497194051743, "timestamp": "2023-12-21 11:10:53.155393+00:00"},
+"16,8,4,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.5839333683252335, "times": [6.594780921936035, 6.649022102355957, 6.595582008361816, 6.571901798248291, 6.5904622077941895, 6.582461833953857, 6.583742141723633, 6.604221820831299, 6.611581802368164, 6.567677974700928, 6.580862045288086, 6.547581195831299, 6.572541236877441, 6.569662094116211, 6.592862129211426, 6.556382179260254, 6.566781997680664, 6.596382141113281, 6.561982154846191, 6.6200737953186035, 6.568861961364746, 6.583581924438477, 6.569342136383057, 6.57846212387085, 6.57078218460083, 6.571901798248291, 6.612222194671631, 6.598301887512207, 6.599582195281982, 6.571041107177734, 6.572220802307129, 6.57302188873291], "compile_time": 2919.133690185845, "verification_time": 0, "benchmark_time": 212.18071598559618, "GFLOP/s": 1146.692528256926, "strategy_time": 0, "framework_time": 1.4061061665415764, "timestamp": "2023-12-21 11:10:56.288128+00:00"},
+"16,8,4,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.231933832168579, "times": [9.513528823852539, 9.243766784667969, 9.242326736450195, 9.235607147216797, 9.225847244262695, 9.234166145324707, 9.222786903381348, 9.223926544189453, 9.226806640625, 9.223767280578613, 9.225526809692383, 9.218965530395508, 9.219765663146973, 9.217986106872559, 9.216086387634277, 9.214165687561035, 9.216726303100586, 9.217206001281738, 9.218647003173828, 9.214966773986816, 9.222334861755371, 9.219125747680664, 9.218006134033203, 9.221206665039062, 9.221047401428223, 9.218807220458984, 9.221527099609375, 9.222428321838379, 9.222326278686523, 9.221366882324219, 9.21912670135498, 9.222006797790527], "compile_time": 650.5615953356028, "verification_time": 0, "benchmark_time": 297.0571150071919, "GFLOP/s": 817.7861038922293, "strategy_time": 0, "framework_time": 1.2994888238608837, "timestamp": "2023-12-21 11:10:57.237062+00:00"},
+"16,8,4,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.147332578897476, "times": [9.20120620727539, 9.170646667480469, 9.157686233520508, 9.15384578704834, 9.151446342468262, 9.156085968017578, 9.148850440979004, 9.14776611328125, 9.145206451416016, 9.143285751342773, 9.150965690612793, 9.142485618591309, 9.140085220336914, 9.144533157348633, 9.145686149597168, 9.140886306762695, 9.142645835876465, 9.142005920410156, 9.141845703125, 9.141205787658691, 9.140716552734375, 9.141526222229004, 9.145846366882324, 9.143125534057617, 9.14168643951416, 9.140246391296387, 9.141845703125, 9.141493797302246, 9.142166137695312, 9.141366004943848, 9.142966270446777, 9.143285751342773], "compile_time": 653.1272092834115, "verification_time": 0, "benchmark_time": 294.5331712253392, "GFLOP/s": 825.3495907011143, "strategy_time": 0, "framework_time": 1.4494196511805058, "timestamp": "2023-12-21 11:10:58.186188+00:00"},
+"16,8,4,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7280562557280064, "times": [1.7585760354995728, 1.7307369709014893, 1.7227369546890259, 1.721776008605957, 1.7195359468460083, 1.7201759815216064, 1.717136025428772, 1.7204960584640503, 1.7216160297393799, 1.952497959136963, 1.7248159646987915, 1.7280160188674927, 1.7216160297393799, 1.7206560373306274, 1.7177759408950806, 1.7208160161972046, 1.7176170349121094, 1.7187360525131226, 1.7198569774627686, 1.717136025428772, 1.7153760194778442, 1.7163360118865967, 1.7203370332717896, 1.7161760330200195, 1.7163360118865967, 1.7153760194778442, 1.7174559831619263, 1.7182559967041016, 1.7185759544372559, 1.7174559831619263, 1.7142560482025146, 1.7195370197296143], "compile_time": 673.4646540135145, "verification_time": 0, "benchmark_time": 56.66725290939212, "GFLOP/s": 4368.9244345922025, "strategy_time": 0, "framework_time": 1.4161569997668266, "timestamp": "2023-12-21 11:10:58.917751+00:00"},
+"16,8,4,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.222598373889923, "times": [9.268885612487793, 9.236726760864258, 9.230647087097168, 9.22408676147461, 9.221845626831055, 9.222167015075684, 9.218393325805664, 9.217367172241211, 9.219447135925293, 9.221527099609375, 9.224726676940918, 9.220247268676758, 9.21816635131836, 9.217110633850098, 9.218006134033203, 9.223286628723145, 9.214006423950195, 9.215126037597656, 9.215286254882812, 9.217845916748047, 9.219586372375488, 9.218326568603516, 9.226806640625, 9.22504711151123, 9.222646713256836, 9.224246978759766, 9.222806930541992, 9.219711303710938, 9.222167015075684, 9.221206665039062, 9.217046737670898, 9.218647003173828], "compile_time": 644.6295860223472, "verification_time": 0, "benchmark_time": 296.7442977242172, "GFLOP/s": 818.6138975078945, "strategy_time": 0, "framework_time": 1.3378430157899857, "timestamp": "2023-12-21 11:10:59.860478+00:00"},
+"16,8,4,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.152511686086655, "times": [9.197525978088379, 9.165045738220215, 9.15544605255127, 9.153685569763184, 9.150646209716797, 9.146965980529785, 9.147287368774414, 9.147605895996094, 9.144084930419922, 9.141526222229004, 9.143925666809082, 9.14504623413086, 9.14008617401123, 9.139963150024414, 9.142485618591309, 9.144085884094238, 9.14344596862793, 9.141205787658691, 9.349847793579102, 9.146965980529785, 9.152048110961914, 9.144246101379395, 9.142965316772461, 9.142806053161621, 9.140726089477539, 9.138166427612305, 9.137845993041992, 9.138189315795898, 9.136885643005371, 9.139604568481445, 9.140886306762695, 9.13912582397461], "compile_time": 643.7225881963968, "verification_time": 0, "benchmark_time": 294.5505762472749, "GFLOP/s": 824.8825523464641, "strategy_time": 0, "framework_time": 1.4804592356085777, "timestamp": "2023-12-21 11:11:00.800246+00:00"},
+"16,8,4,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 11.868776768445969, "times": [11.85835075378418, 11.921392440795898, 11.739789962768555, 11.931632041931152, 11.923151969909668, 11.963945388793945, 11.91755199432373, 11.859151840209961, 11.71658992767334, 11.854511260986328, 11.918831825256348, 11.869012832641602, 11.973551750183105, 11.903471946716309, 11.95627212524414, 11.93371295928955, 11.869872093200684, 11.930375099182129, 11.760270118713379, 12.01179313659668, 11.87723159790039, 11.832592010498047, 11.947312355041504, 11.929685592651367, 11.866671562194824, 11.862031936645508, 11.631150245666504, 11.781710624694824, 11.68554973602295, 11.911067962646484, 11.736909866333008, 11.925711631774902], "compile_time": 5330.3148010745645, "verification_time": 0, "benchmark_time": 381.58049806952477, "GFLOP/s": 636.1015416577358, "strategy_time": 0, "framework_time": 1.367230899631977, "timestamp": "2023-12-21 11:11:06.513525+00:00"},
+"16,8,4,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.548777848482132, "times": [7.644230842590332, 7.557991027832031, 7.553350925445557, 7.54823112487793, 7.53623104095459, 7.543591022491455, 7.535110950469971, 7.53463077545166, 7.540926933288574, 7.530150890350342, 7.536709785461426, 7.533670902252197, 7.566151142120361, 7.5359110832214355, 7.528390884399414, 7.533669948577881, 7.530951023101807, 7.567468166351318, 7.534310817718506, 7.533350944519043, 7.527430057525635, 7.530311107635498, 7.576871871948242, 7.53463077545166, 7.52423095703125, 7.526309967041016, 7.52947998046875, 7.735753059387207, 7.548070907592773, 7.533830165863037, 7.5408711433410645, 7.52807092666626], "compile_time": 1286.2506699748337, "verification_time": 0, "benchmark_time": 243.50527999922633, "GFLOP/s": 1000.1284117160849, "strategy_time": 0, "framework_time": 1.3675321824848652, "timestamp": "2023-12-21 11:11:08.044663+00:00"},
+"16,8,4,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.542166709899902, "times": [7.638791084289551, 7.567750930786133, 7.533990859985352, 7.547750949859619, 7.578151226043701, 7.570950984954834, 7.532229900360107, 7.526791095733643, 7.564644813537598, 7.533191204071045, 7.512711048126221, 7.547911167144775, 7.5410308837890625, 7.531429767608643, 7.526310920715332, 7.538471221923828, 7.531590938568115, 7.530419826507568, 7.531589984893799, 7.521670818328857, 7.545670986175537, 7.548070907592773, 7.527750015258789, 7.538150787353516, 7.5431108474731445, 7.534951210021973, 7.552377223968506, 7.509990215301514, 7.531429767608643, 7.549351215362549, 7.529510974884033, 7.531590938568115], "compile_time": 1390.7149410806596, "verification_time": 0, "benchmark_time": 242.9904816672206, "GFLOP/s": 1001.005081217596, "strategy_time": 0, "framework_time": 1.4075902290642262, "timestamp": "2023-12-21 11:11:09.679793+00:00"},
+"16,8,4,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.639538928866386, "times": [7.709832191467285, 7.648551940917969, 7.648392200469971, 7.663271903991699, 7.662471771240234, 7.6634321212768555, 7.652872085571289, 7.664072036743164, 7.640254974365234, 7.6503119468688965, 7.656231880187988, 7.647272109985352, 7.652871131896973, 7.664072036743164, 7.6675920486450195, 7.649991989135742, 7.657832145690918, 7.625868797302246, 7.63175106048584, 7.626630783081055, 7.613670825958252, 7.604550838470459, 7.590950965881348, 7.626311779022217, 7.6147918701171875, 7.628712177276611, 7.613999843597412, 7.619592189788818, 7.622791767120361, 7.614312171936035, 7.625351905822754, 7.606632232666016], "compile_time": 1391.140114981681, "verification_time": 0, "benchmark_time": 246.0980759933591, "GFLOP/s": 988.2464465850021, "strategy_time": 0, "framework_time": 1.4081201516091824, "timestamp": "2023-12-21 11:11:11.318455+00:00"},
+"16,8,4,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.618232861161232, "times": [7.711431980133057, 7.665192127227783, 7.659751892089844, 7.881194114685059, 7.679431915283203, 7.621830940246582, 7.604391098022461, 7.617831230163574, 7.581143856048584, 7.595430850982666, 7.602790832519531, 7.596070766448975, 7.594631195068359, 7.583432197570801, 7.576870918273926, 7.623910903930664, 7.588231086730957, 7.604949951171875, 7.60119104385376, 7.595911026000977, 7.617512226104736, 7.588710784912109, 7.60935115814209, 7.598311901092529, 7.579912185668945, 7.581830978393555, 7.60328483581543, 7.591111183166504, 7.604711055755615, 7.583432197570801, 7.63975191116333, 7.599911212921143], "compile_time": 1293.7918403185904, "verification_time": 0, "benchmark_time": 245.2859920449555, "GFLOP/s": 991.0102956408197, "strategy_time": 0, "framework_time": 1.5138350427150726, "timestamp": "2023-12-21 11:11:12.859061+00:00"},
+"16,8,4,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.573267579078674, "times": [7.665670871734619, 7.602150917053223, 7.585031032562256, 7.5784711837768555, 7.559590816497803, 7.591752052307129, 7.556711196899414, 7.5848708152771, 7.5583720207214355, 7.564391136169434, 7.580871105194092, 7.615110874176025, 7.556550979614258, 7.5653510093688965, 7.543590068817139, 7.583590984344482, 7.573192119598389, 7.593887805938721, 7.61303186416626, 7.583110809326172, 7.562790870666504, 7.564711093902588, 7.549671173095703, 7.55479097366333, 7.564230918884277, 7.565511226654053, 7.554562091827393, 7.547270774841309, 7.540710926055908, 7.586471080780029, 7.549510955810547, 7.549030780792236], "compile_time": 1344.5868389680982, "verification_time": 0, "benchmark_time": 243.78945073112845, "GFLOP/s": 996.8942891779434, "strategy_time": 0, "framework_time": 1.275593414902687, "timestamp": "2023-12-21 11:11:14.448728+00:00"},
+"16,8,4,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 47.59263777732849, "times": [47.565086364746094, 47.71065902709961, 47.56732940673828, 47.48959732055664, 47.57660675048828, 47.723758697509766, 47.63996887207031, 47.840049743652344, 47.62732696533203, 47.53715133666992, 47.69004821777344, 47.616600036621094, 47.6767692565918, 47.80632019042969, 47.420448303222656, 47.47817611694336, 47.44188690185547, 47.79548645019531, 47.6844482421875, 47.38496017456055, 47.51900863647461, 47.58712387084961, 47.4439697265625, 47.5532341003418, 47.684288024902344, 47.55113220214844, 47.72060775756836, 47.52684020996094, 47.7050895690918, 47.505699157714844, 47.50556945800781, 47.38916778564453], "compile_time": 3440.883805975318, "verification_time": 0, "benchmark_time": 1524.4824877008796, "GFLOP/s": 158.63266993779533, "strategy_time": 0, "framework_time": 1.4199037104845047, "timestamp": "2023-12-21 11:11:19.415529+00:00"},
+"16,8,4,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.6571134775877, "times": [7.703752040863037, 7.668551921844482, 7.660071849822998, 7.667111873626709, 7.660071849822998, 7.655752182006836, 7.657192230224609, 7.657192230224609, 7.653927803039551, 7.655752182006836, 7.655432224273682, 7.657351970672607, 7.650951862335205, 7.658472061157227, 7.660391807556152, 7.653831958770752, 7.653670787811279, 7.65486478805542, 7.651112079620361, 7.655272006988525, 7.651591777801514, 7.650951862335205, 7.655752182006836, 7.653031826019287, 7.653030872344971, 7.653192043304443, 7.6521148681640625, 7.651591777801514, 7.649511814117432, 7.654791831970215, 7.654790878295898, 7.656551837921143], "compile_time": 903.0721038579941, "verification_time": 0, "benchmark_time": 246.5403750538826, "GFLOP/s": 985.9782308435209, "strategy_time": 0, "framework_time": 1.5066112391650677, "timestamp": "2023-12-21 11:11:20.566665+00:00"},
+"16,8,4,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.478309765458107, "times": [7.515270233154297, 7.481191158294678, 7.474630832672119, 7.473830223083496, 7.4691901206970215, 7.468070030212402, 7.4679107666015625, 7.471749782562256, 7.465977191925049, 7.4671101570129395, 7.469989776611328, 7.467430114746094, 7.46743106842041, 7.467430114746094, 7.4739909172058105, 7.465670108795166, 7.4671101570129395, 7.4647440910339355, 7.463429927825928, 7.468550205230713, 7.465829849243164, 7.672872066497803, 7.468070983886719, 7.470469951629639, 7.465350151062012, 7.467909812927246, 7.465153217315674, 7.467909812927246, 7.467909812927246, 7.466949939727783, 7.532710075378418, 7.464069843292236], "compile_time": 902.4724410846829, "verification_time": 0, "benchmark_time": 241.3081508129835, "GFLOP/s": 1009.5526177414926, "strategy_time": 0, "framework_time": 1.3574822805821896, "timestamp": "2023-12-21 11:11:21.711818+00:00"},
+"16,8,4,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 48.049014925956726, "times": [47.8842887878418, 48.03059387207031, 47.994850158691406, 48.37220764160156, 48.239810943603516, 48.394412994384766, 48.373897552490234, 48.26388168334961, 48.02285385131836, 47.826385498046875, 48.14349365234375, 48.074153900146484, 47.99997329711914, 48.184349060058594, 48.06685256958008, 47.721160888671875, 47.88636779785156, 48.13947296142578, 47.919166564941406, 48.087764739990234, 48.51117706298828, 48.04441452026367, 47.74748611450195, 48.160369873046875, 47.96556854248047, 47.77131271362305, 47.74300765991211, 47.76713562011719, 48.422855377197266, 47.76795196533203, 48.05997085571289, 47.98128890991211], "compile_time": 4465.402272064239, "verification_time": 0, "benchmark_time": 1539.164891000837, "GFLOP/s": 157.12595173145837, "strategy_time": 0, "framework_time": 1.445550937205553, "timestamp": "2023-12-21 11:11:27.717846+00:00"},
+"16,8,4,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.664159879088402, "times": [7.704071998596191, 7.677832126617432, 7.667272090911865, 7.660232067108154, 7.658631801605225, 7.655111789703369, 7.655432224273682, 7.654632091522217, 7.6576690673828125, 7.653031826019287, 7.655111789703369, 7.6563920974731445, 7.650472164154053, 7.653992176055908, 7.651432037353516, 7.652071952819824, 7.653512001037598, 7.657113075256348, 7.653992176055908, 7.656231880187988, 7.654632091522217, 7.656871795654297, 7.654151916503906, 7.655752182006836, 7.651432037353516, 7.662312030792236, 7.6527252197265625, 7.6594319343566895, 7.652711868286133, 7.653831958770752, 7.858153820037842, 7.6568708419799805], "compile_time": 904.2260199785233, "verification_time": 0, "benchmark_time": 246.7754897661507, "GFLOP/s": 985.0717259434297, "strategy_time": 0, "framework_time": 1.4581182040274143, "timestamp": "2023-12-21 11:11:28.870322+00:00"},
+"16,8,4,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.469588100910187, "times": [7.517189979553223, 7.4845499992370605, 7.479109764099121, 7.474949836730957, 7.472390174865723, 7.473670959472656, 7.4671101570129395, 7.4763898849487305, 7.467723846435547, 7.4682297706604, 7.4682297706604, 7.46550989151001, 7.4671101570129395, 7.4669508934021, 7.464069843292236, 7.466790199279785, 7.46550989151001, 7.465069770812988, 7.468070030212402, 7.4658308029174805, 7.464389801025391, 7.4651899337768555, 7.466149806976318, 7.464391231536865, 7.463749885559082, 7.466629981994629, 7.463832855224609, 7.4693498611450195, 7.46327018737793, 7.461830139160156, 7.466629981994629, 7.466949939727783], "compile_time": 902.4328850209713, "verification_time": 0, "benchmark_time": 240.97171006724238, "GFLOP/s": 1010.7313948248426, "strategy_time": 0, "framework_time": 1.4468939043581486, "timestamp": "2023-12-21 11:11:30.015189+00:00"},
+"16,8,4,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 13.72605076432228, "times": [13.734368324279785, 13.693888664245605, 13.76172924041748, 13.769248962402344, 13.733124732971191, 13.673728942871094, 13.802530288696289, 13.679808616638184, 13.748608589172363, 13.688279151916504, 13.753568649291992, 13.666687965393066, 13.786528587341309, 13.696449279785156, 13.74686336517334, 13.714849472045898, 13.722208976745605, 13.664287567138672, 13.710528373718262, 13.683646202087402, 13.726049423217773, 13.76076889038086, 13.724609375, 13.734528541564941, 13.752012252807617, 13.703808784484863, 13.699329376220703, 13.743648529052734, 13.730209350585938, 13.715147018432617, 13.817729949951172, 13.694849014282227], "compile_time": 1858.0519743263721, "verification_time": 0, "benchmark_time": 440.87564619258046, "GFLOP/s": 550.0305462678191, "strategy_time": 0, "framework_time": 1.533352304250002, "timestamp": "2023-12-21 11:11:32.315666+00:00"},
+"16,8,4,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.217967987060547, "times": [9.263445854187012, 9.222806930541992, 9.2103271484375, 9.227446556091309, 9.213526725769043, 9.203126907348633, 9.211869239807129, 9.484088897705078, 9.211285591125488, 9.202325820922852, 9.216245651245117, 9.203286170959473, 9.193045616149902, 9.208963394165039, 9.222167015075684, 9.208887100219727, 9.218167304992676, 9.199127197265625, 9.198966979980469, 9.19240665435791, 9.201581001281738, 9.212726593017578, 9.213526725769043, 9.203606605529785, 9.202807426452637, 9.204887390136719, 9.199446678161621, 9.20229434967041, 9.204886436462402, 9.198166847229004, 9.197526931762695, 9.222005844116211], "compile_time": 1293.298632837832, "verification_time": 0, "benchmark_time": 296.75304470583797, "GFLOP/s": 819.0251051639295, "strategy_time": 0, "framework_time": 1.403531525284052, "timestamp": "2023-12-21 11:11:33.907136+00:00"},
+"16,8,4,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.119606047868729, "times": [9.171765327453613, 9.15048599243164, 9.122964859008789, 9.121845245361328, 9.129205703735352, 9.124884605407715, 9.111804962158203, 9.121685981750488, 9.117205619812012, 9.113526344299316, 9.113365173339844, 9.138646125793457, 9.114485740661621, 9.104166030883789, 9.109524726867676, 9.109525680541992, 9.111125946044922, 9.134965896606445, 9.115285873413086, 9.107444763183594, 9.113500595092773, 9.12568473815918, 9.118005752563477, 9.114645004272461, 9.117364883422852, 9.13464641571045, 9.106644630432129, 9.104809761047363, 9.097365379333496, 9.110804557800293, 9.127765655517578, 9.112245559692383], "compile_time": 1291.5648017078638, "verification_time": 0, "benchmark_time": 293.45846781507134, "GFLOP/s": 827.8589185071642, "strategy_time": 0, "framework_time": 1.3889926485717297, "timestamp": "2023-12-21 11:11:35.493563+00:00"},
+"16,8,4,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 2.384048745036125, "times": [2.421462059020996, 2.392021894454956, 2.389781951904297, 2.376343011856079, 2.3888230323791504, 2.378103017807007, 2.370102882385254, 2.3837029933929443, 2.360502004623413, 2.3718628883361816, 2.3709030151367188, 2.3739418983459473, 2.3710620403289795, 2.3582630157470703, 2.3728220462799072, 2.3673830032348633, 2.592184066772461, 2.378422975540161, 2.393781900405884, 2.3800230026245117, 2.3779420852661133, 2.374423027038574, 2.3637020587921143, 2.3753819465637207, 2.3837029933929443, 2.3743019104003906, 2.378741979598999, 2.3609819412231445, 2.3833820819854736, 2.3747429847717285, 2.381782054901123, 2.3689820766448975], "compile_time": 1451.021530199796, "verification_time": 0, "benchmark_time": 77.57629593834281, "GFLOP/s": 3166.7755182101355, "strategy_time": 0, "framework_time": 1.496591605246067, "timestamp": "2023-12-21 11:11:37.023673+00:00"},
+"16,8,4,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.221016258001328, "times": [9.2749662399292, 9.226487159729004, 9.234967231750488, 9.231447219848633, 9.215766906738281, 9.220566749572754, 9.230381965637207, 9.22536563873291, 9.20632553100586, 9.210165977478027, 9.206485748291016, 9.211127281188965, 9.233527183532715, 9.21274185180664, 9.219926834106445, 9.226487159729004, 9.218167304992676, 9.216246604919434, 9.231607437133789, 9.213367462158203, 9.220035552978516, 9.226806640625, 9.209527015686035, 9.211286544799805, 9.210006713867188, 9.216887474060059, 9.212567329406738, 9.211409568786621, 9.240086555480957, 9.224886894226074, 9.203447341918945, 9.219447135925293], "compile_time": 1293.4729913249612, "verification_time": 0, "benchmark_time": 296.66885174810886, "GFLOP/s": 818.754352965041, "strategy_time": 0, "framework_time": 1.3634427450597286, "timestamp": "2023-12-21 11:11:38.615194+00:00"},
+"16,8,4,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 8, "tile_size_x": 4, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.120768010616302, "times": [9.167764663696289, 9.125526428222656, 9.117046356201172, 9.12280559539795, 9.12216567993164, 9.108566284179688, 9.117074966430664, 9.119444847106934, 9.12280559539795, 9.11512565612793, 9.120085716247559, 9.110806465148926, 9.112244606018066, 9.102952003479004, 9.119125366210938, 9.106486320495605, 9.128565788269043, 9.105525970458984, 9.11336612701416, 9.105846405029297, 9.106485366821289, 9.10760498046875, 9.103124618530273, 9.102644920349121, 9.105525016784668, 9.321368217468262, 9.115285873413086, 9.105422973632812, 9.104405403137207, 9.10584545135498, 9.11496639251709, 9.108566284179688], "compile_time": 1291.504364926368, "verification_time": 0, "benchmark_time": 293.1750090792775, "GFLOP/s": 827.7534513773751, "strategy_time": 0, "framework_time": 1.3719690032303333, "timestamp": "2023-12-21 11:11:40.201260+00:00"},
+"16,16,1,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 3.534782037138939, "times": [3.564992904663086, 3.5392329692840576, 3.5435540676116943, 3.5326740741729736, 3.530272960662842, 3.530272960662842, 3.53363299369812, 3.5384340286254883, 3.539393901824951, 3.5317130088806152, 3.5331530570983887, 3.530592918395996, 3.5337929725646973, 3.5374739170074463, 3.5301129817962646, 3.5320329666137695, 3.5323541164398193, 3.5299129486083984, 3.538593053817749, 3.5309131145477295, 3.5337939262390137, 3.532352924346924, 3.5323541164398193, 3.5310730934143066, 3.531393051147461, 3.5307528972625732, 3.531393051147461, 3.5395541191101074, 3.528352975845337, 3.5373129844665527, 3.5368330478668213, 3.5347530841827393], "compile_time": 659.8759619519114, "verification_time": 0, "benchmark_time": 115.12893484905362, "GFLOP/s": 2135.8451866839246, "strategy_time": 0, "framework_time": 1.5010498464107513, "timestamp": "2023-12-21 11:11:40.977781+00:00"},
+"16,16,1,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.783352792263031, "times": [9.830331802368164, 9.803451538085938, 9.7944917678833, 9.788891792297363, 9.787291526794434, 9.781691551208496, 9.779513359069824, 9.780411720275879, 9.783931732177734, 9.780092239379883, 9.77833080291748, 9.779611587524414, 9.786492347717285, 9.77963924407959, 9.777531623840332, 9.778491973876953, 9.779292106628418, 9.785852432250977, 9.77881145477295, 9.77833080291748, 9.778078079223633, 9.776412010192871, 9.781211853027344, 9.779611587524414, 9.783452033996582, 9.777852058410645, 9.780252456665039, 9.779328346252441, 9.780571937561035, 9.780732154846191, 9.776891708374023, 9.780411720275879], "compile_time": 330.9567510150373, "verification_time": 0, "benchmark_time": 314.34458680450916, "GFLOP/s": 771.6932385358285, "strategy_time": 0, "framework_time": 1.3872100971639156, "timestamp": "2023-12-21 11:11:41.624485+00:00"},
+"16,16,1,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.783823192119598, "times": [9.825211524963379, 10.03305435180664, 9.788412094116211, 9.781850814819336, 9.782172203063965, 9.777372360229492, 9.780893325805664, 9.775931358337402, 9.77705192565918, 9.774811744689941, 9.773371696472168, 9.772090911865234, 9.773051261901855, 9.773002624511719, 9.774651527404785, 9.772412300109863, 9.773531913757324, 9.77129077911377, 9.769851684570312, 9.768571853637695, 9.766819953918457, 9.772570610046387, 9.768411636352539, 9.770812034606934, 9.769692420959473, 9.774011611938477, 9.7682523727417, 9.770895004272461, 9.778491973876953, 9.774492263793945, 9.774011611938477, 9.77529239654541], "compile_time": 330.80823300406337, "verification_time": 0, "benchmark_time": 314.5114411599934, "GFLOP/s": 771.6561360267589, "strategy_time": 0, "framework_time": 1.3020439073443413, "timestamp": "2023-12-21 11:11:42.271121+00:00"},
+"16,16,1,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7979869022965431, "times": [1.8347359895706177, 1.8040169477462769, 1.8032170534133911, 1.7996970415115356, 1.797616958618164, 1.7963370084762573, 1.797456979751587, 1.795536994934082, 1.7950570583343506, 1.797616958618164, 1.800176978111267, 1.7956969738006592, 1.7950570583343506, 1.7964969873428345, 1.7937769889831543, 1.7944170236587524, 1.7948969602584839, 1.7984169721603394, 1.7950570583343506, 1.799536943435669, 1.7964969873428345, 1.7972960472106934, 1.7939369678497314, 1.797616958618164, 1.7952170372009277, 1.7984169721603394, 1.7944170236587524, 1.7944159507751465, 1.7958569526672363, 1.7936170101165771, 1.7977770566940308, 1.7956969738006592], "compile_time": 350.7529371418059, "verification_time": 0, "benchmark_time": 59.637370985001326, "GFLOP/s": 4199.0001097098175, "strategy_time": 0, "framework_time": 1.377129927277565, "timestamp": "2023-12-21 11:11:42.682902+00:00"},
+"16,16,1,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.787596732378006, "times": [9.834491729736328, 9.799291610717773, 9.79001235961914, 9.785371780395508, 9.79609203338623, 9.783772468566895, 9.781649589538574, 9.780892372131348, 9.778331756591797, 9.77529239654541, 9.99001407623291, 9.776891708374023, 9.774651527404785, 9.781634330749512, 9.778011322021484, 9.780252456665039, 9.774971961975098, 9.776091575622559, 9.775132179260254, 9.77865219116211, 9.776930809020996, 9.773531913757324, 9.775772094726562, 9.773530960083008, 9.777690887451172, 9.773531913757324, 9.776572227478027, 9.774065017700195, 9.773531913757324, 9.774971961975098, 9.780732154846191, 9.780732154846191], "compile_time": 326.2119428254664, "verification_time": 0, "benchmark_time": 314.5703957416117, "GFLOP/s": 771.3586293379809, "strategy_time": 0, "framework_time": 1.2323795817792416, "timestamp": "2023-12-21 11:11:43.324931+00:00"},
+"16,16,1,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.776077419519424, "times": [9.827932357788086, 9.794651985168457, 9.786171913146973, 9.7780122756958, 9.773852348327637, 9.776891708374023, 9.774100303649902, 9.772571563720703, 9.770332336425781, 9.769851684570312, 9.777212142944336, 9.769692420959473, 9.76937198638916, 9.769386291503906, 9.77225112915039, 9.773212432861328, 9.770812034606934, 9.768892288208008, 9.776891708374023, 9.769532203674316, 9.78104305267334, 9.771291732788086, 9.770491600036621, 9.785531997680664, 9.773371696472168, 9.772252082824707, 9.770331382751465, 9.780013084411621, 9.7728910446167, 9.7780122756958, 9.768732070922852, 9.768892288208008], "compile_time": 327.0618598908186, "verification_time": 0, "benchmark_time": 314.17492823675275, "GFLOP/s": 772.267533901254, "strategy_time": 0, "framework_time": 1.3662599958479404, "timestamp": "2023-12-21 11:11:43.967550+00:00"},
+"16,16,1,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7808918729424477, "times": [1.8105759620666504, 1.7840169668197632, 1.7737770080566406, 1.7753770351409912, 1.7833770513534546, 1.7713769674301147, 1.7728170156478882, 1.7712169885635376, 1.7720160484313965, 1.774256944656372, 1.7731369733810425, 1.7707370519638062, 1.769616961479187, 1.7704169750213623, 1.7734570503234863, 1.7723360061645508, 1.7788970470428467, 1.774096965789795, 1.7699370384216309, 1.9790589809417725, 1.7731369733810425, 1.7779370546340942, 1.7684969902038574, 1.7707370519638062, 1.771536946296692, 1.7710570096969604, 1.7769769430160522, 1.769616961479187, 1.7728159427642822, 1.7683360576629639, 1.7763359546661377, 1.7710570096969604], "compile_time": 535.4063399136066, "verification_time": 0, "benchmark_time": 58.394310995936394, "GFLOP/s": 4239.306897125686, "strategy_time": 0, "framework_time": 1.356238964945078, "timestamp": "2023-12-21 11:11:44.562722+00:00"},
+"16,16,1,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.471450537443161, "times": [9.520729064941406, 9.491128921508789, 9.480249404907227, 9.478328704833984, 9.470329284667969, 9.468408584594727, 9.4682035446167, 9.468729019165039, 9.468729019165039, 9.46712875366211, 9.46808910369873, 9.467288970947266, 9.466968536376953, 9.475139617919922, 9.467288970947266, 9.470169067382812, 9.467288970947266, 9.469529151916504, 9.469368934631348, 9.467609405517578, 9.466876029968262, 9.468249320983887, 9.46808910369873, 9.46808910369873, 9.466169357299805, 9.472569465637207, 9.469049453735352, 9.463945388793945, 9.464888572692871, 9.471928596496582, 9.465848922729492, 9.470008850097656], "compile_time": 429.24520978704095, "verification_time": 0, "benchmark_time": 305.0422640517354, "GFLOP/s": 797.1056988740894, "strategy_time": 0, "framework_time": 1.365156378597021, "timestamp": "2023-12-21 11:11:45.298389+00:00"},
+"16,16,1,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.44083645939827, "times": [9.482168197631836, 9.456409454345703, 9.445049285888672, 9.440408706665039, 9.437047958374023, 9.434968948364258, 9.43378734588623, 9.431927680969238, 9.433209419250488, 9.437368392944336, 9.437687873840332, 9.433368682861328, 9.430168151855469, 9.428668022155762, 9.427448272705078, 9.428248405456543, 9.427448272705078, 9.436568260192871, 9.430808067321777, 9.43224811553955, 9.42838191986084, 9.434167861938477, 9.431928634643555, 9.425048828125, 9.422489166259766, 9.434967994689941, 9.42824935913086, 9.432811737060547, 9.624730110168457, 9.437047958374023, 9.431927680969238, 9.430007934570312], "compile_time": 430.72318471968174, "verification_time": 0, "benchmark_time": 303.5075389780104, "GFLOP/s": 799.6904969669602, "strategy_time": 0, "framework_time": 1.4925342984497547, "timestamp": "2023-12-21 11:11:46.034127+00:00"},
+"16,16,1,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.771376620978117, "times": [1.8099360466003418, 1.775696039199829, 1.7737770080566406, 1.7824170589447021, 1.769616961479187, 1.7705769538879395, 1.7723369598388672, 1.7702569961547852, 1.7716959714889526, 1.7691359519958496, 1.7734559774398804, 1.7688159942626953, 1.7694560289382935, 1.7676960229873657, 1.7681759595870972, 1.7683370113372803, 1.7686560153961182, 1.7688159942626953, 1.7681759595870972, 1.7691370248794556, 1.7683370113372803, 1.7702569961547852, 1.7686569690704346, 1.7694569826126099, 1.7684969902038574, 1.7692970037460327, 1.7723369598388672, 1.767056941986084, 1.768017053604126, 1.768017053604126, 1.7686569690704346, 1.7692970037460327], "compile_time": 520.4197866842151, "verification_time": 0, "benchmark_time": 58.21455270051956, "GFLOP/s": 4262.079057942623, "strategy_time": 0, "framework_time": 1.4817728661000729, "timestamp": "2023-12-21 11:11:46.614259+00:00"},
+"16,16,1,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.4706189930439, "times": [9.517048835754395, 9.48776912689209, 9.480408668518066, 9.47576904296875, 9.473689079284668, 9.470648765563965, 9.470900535583496, 9.467609405517578, 9.468729019165039, 9.468568801879883, 9.472728729248047, 9.467768669128418, 9.467449188232422, 9.466236114501953, 9.466169357299805, 9.469529151916504, 9.46808910369873, 9.46808910369873, 9.464888572692871, 9.472249031066895, 9.465786933898926, 9.476408958435059, 9.468408584594727, 9.468729019165039, 9.465529441833496, 9.466809272766113, 9.465048789978027, 9.46399211883545, 9.461688995361328, 9.466169357299805, 9.462968826293945, 9.463929176330566], "compile_time": 423.80419094115496, "verification_time": 0, "benchmark_time": 304.94575714692473, "GFLOP/s": 797.1756867787875, "strategy_time": 0, "framework_time": 1.3901656493544579, "timestamp": "2023-12-21 11:11:47.344414+00:00"},
+"16,16,1,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.44193571805954, "times": [9.480088233947754, 9.452729225158691, 9.444568634033203, 9.441688537597656, 9.435929298400879, 9.659770011901855, 9.433899879455566, 9.437368392944336, 9.432408332824707, 9.430487632751465, 9.430968284606934, 9.43096923828125, 9.428729057312012, 9.432819366455078, 9.430647850036621, 9.433209419250488, 9.430648803710938, 9.431448936462402, 9.431928634643555, 9.428088188171387, 9.429702758789062, 9.443928718566895, 9.430809020996094, 9.433368682861328, 9.432088851928711, 9.427449226379395, 9.428568840026855, 9.432477951049805, 9.429847717285156, 9.431768417358398, 9.429848670959473, 9.433688163757324], "compile_time": 425.71727093309164, "verification_time": 0, "benchmark_time": 303.7026710808277, "GFLOP/s": 799.5973945850573, "strategy_time": 0, "framework_time": 1.3535539619624615, "timestamp": "2023-12-21 11:11:48.075202+00:00"},
+"16,16,1,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.28167736530304, "times": [34.31184005737305, 34.24502944946289, 34.40240478515625, 34.29074478149414, 34.26464080810547, 34.6850471496582, 34.27248001098633, 34.26335906982422, 34.262081146240234, 34.218387603759766, 34.236480712890625, 34.26203536987305, 34.217281341552734, 34.226016998291016, 34.250240325927734, 34.25300979614258, 34.2729606628418, 34.23234558105469, 34.25088119506836, 34.24580001831055, 34.24016189575195, 34.240631103515625, 34.21184158325195, 34.268653869628906, 34.52272415161133, 34.274383544921875, 34.29216003417969, 34.277244567871094, 34.27056121826172, 34.27004623413086, 34.223201751708984, 34.25899887084961], "compile_time": 2716.7092631570995, "verification_time": 0, "benchmark_time": 1098.549157846719, "GFLOP/s": 220.2268902874981, "strategy_time": 0, "framework_time": 1.3902541249990463, "timestamp": "2023-12-21 11:11:51.891866+00:00"},
+"16,16,1,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 14.949569642543793, "times": [15.056620597839355, 15.032140731811523, 14.918379783630371, 15.017420768737793, 15.150050163269043, 14.910860061645508, 14.933740615844727, 14.792139053344727, 15.007020950317383, 14.981905937194824, 15.010701179504395, 14.915019989013672, 14.825738906860352, 14.874699592590332, 15.128445625305176, 14.733098030090332, 15.043980598449707, 14.951980590820312, 15.049262046813965, 14.912540435791016, 14.925259590148926, 14.762377738952637, 14.862858772277832, 15.03070068359375, 15.193811416625977, 14.918540000915527, 15.015021324157715, 14.960140228271484, 14.998701095581055, 14.776473045349121, 14.694058418273926, 15.002540588378906], "compile_time": 562.4927068129182, "verification_time": 0, "benchmark_time": 479.87376525998116, "GFLOP/s": 505.0143502803434, "strategy_time": 0, "framework_time": 1.4860299415886402, "timestamp": "2023-12-21 11:11:52.935734+00:00"},
+"16,16,1,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.143824577331543, "times": [15.112940788269043, 15.22030258178711, 15.201263427734375, 15.284302711486816, 15.043416023254395, 15.130702018737793, 15.11230182647705, 15.215343475341797, 15.09150218963623, 15.117919921875, 15.085421562194824, 15.18414306640625, 15.208622932434082, 15.066540718078613, 15.122879028320312, 15.202062606811523, 15.10526180267334, 15.079022407531738, 15.078381538391113, 15.107337951660156, 15.15774154663086, 15.165262222290039, 15.140462875366211, 15.185262680053711, 15.07120132446289, 15.217263221740723, 15.152141571044922, 15.155342102050781, 15.141422271728516, 15.139613151550293, 15.22286319732666, 15.084141731262207], "compile_time": 560.1077540777624, "verification_time": 0, "benchmark_time": 486.16788629442453, "GFLOP/s": 498.5363612373753, "strategy_time": 0, "framework_time": 1.4310246333479881, "timestamp": "2023-12-21 11:11:53.983456+00:00"},
+"16,16,1,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.5779093503952, "times": [34.76096725463867, 34.547733306884766, 34.579524993896484, 34.62708282470703, 34.582244873046875, 34.54496765136719, 34.59072494506836, 34.55219268798828, 34.59040451049805, 34.621768951416016, 34.541603088378906, 34.53345489501953, 34.57248306274414, 34.58987045288086, 34.56704330444336, 34.583316802978516, 34.565765380859375, 34.550804138183594, 34.547523498535156, 34.5128173828125, 34.5339241027832, 34.540733337402344, 34.58000564575195, 34.773929595947266, 34.594085693359375, 34.569000244140625, 34.542564392089844, 34.52558135986328, 34.57424545288086, 34.56374740600586, 34.54512405395508, 34.58786392211914], "compile_time": 4234.20567298308, "verification_time": 0, "benchmark_time": 1107.9177390784025, "GFLOP/s": 218.34018718409624, "strategy_time": 0, "framework_time": 1.3502375222742558, "timestamp": "2023-12-21 11:11:59.326944+00:00"},
+"16,16,1,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.00919833779335, "times": [15.141740798950195, 15.029741287231445, 14.942219734191895, 15.028780937194824, 14.73550796508789, 14.875340461730957, 15.026862144470215, 15.073262214660645, 15.064142227172852, 14.979778289794922, 15.123982429504395, 14.959019660949707, 15.127182006835938, 15.053582191467285, 14.989301681518555, 14.881420135498047, 14.817259788513184, 14.97390079498291, 15.1900634765625, 15.06142807006836, 15.166543006896973, 14.8785400390625, 14.852299690246582, 15.001581192016602, 15.133976936340332, 15.115021705627441, 14.874380111694336, 15.08894157409668, 15.002381324768066, 15.021561622619629, 15.042381286621094, 15.042222023010254], "compile_time": 563.0520819686353, "verification_time": 0, "benchmark_time": 482.0401440374553, "GFLOP/s": 503.0080241520722, "strategy_time": 0, "framework_time": 1.4172177761793137, "timestamp": "2023-12-21 11:12:00.373469+00:00"},
+"16,16,1,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.21128037571907, "times": [15.26942253112793, 15.184782981872559, 15.288143157958984, 15.233742713928223, 15.267767906188965, 15.171503067016602, 15.168622016906738, 15.149581909179688, 15.350225448608398, 15.302675247192383, 15.128941535949707, 15.186702728271484, 15.34798526763916, 15.155503273010254, 15.153453826904297, 15.171181678771973, 15.217903137207031, 15.219983100891113, 15.231022834777832, 15.255048751831055, 15.14398193359375, 15.219503402709961, 15.155662536621094, 15.323023796081543, 15.185327529907227, 15.135501861572266, 15.292143821716309, 15.114702224731445, 15.146862030029297, 15.205463409423828, 15.290384292602539, 15.094222068786621], "compile_time": 562.1556742116809, "verification_time": 0, "benchmark_time": 488.32464776933193, "GFLOP/s": 496.3255566606507, "strategy_time": 0, "framework_time": 1.495429314672947, "timestamp": "2023-12-21 11:12:01.425462+00:00"},
+"16,16,1,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7706968188285828, "times": [2.044018030166626, 1.7731369733810425, 1.7664170265197754, 1.7652970552444458, 1.763537049293518, 1.7619370222091675, 1.76289701461792, 1.7612969875335693, 1.7612969875335693, 1.763056993484497, 1.7699370384216309, 1.7612969875335693, 1.7606569528579712, 1.7601770162582397, 1.7625770568847656, 1.7598570585250854, 1.7585769891738892, 1.7614569664001465, 1.7601770162582397, 1.7600170373916626, 1.7600159645080566, 1.7595360279083252, 1.760977029800415, 1.7656170129776, 1.7595369815826416, 1.7595369815826416, 1.760496973991394, 1.7592159509658813, 1.7600159645080566, 1.7603360414505005, 1.7600159645080566, 1.759376049041748], "compile_time": 889.4803803414106, "verification_time": 0, "benchmark_time": 58.222128078341484, "GFLOP/s": 4263.71534625255, "strategy_time": 0, "framework_time": 1.274340320378542, "timestamp": "2023-12-21 11:12:02.374454+00:00"},
+"16,16,1,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.172652542591095, "times": [9.218965530395508, 9.186326026916504, 9.180087089538574, 9.178167343139648, 9.179925918579102, 9.179126739501953, 9.171643257141113, 9.172406196594238, 9.16744613647461, 9.168246269226074, 9.168886184692383, 9.167285919189453, 9.171126365661621, 9.169049263000488, 9.170645713806152, 9.168086051940918, 9.167925834655762, 9.168886184692383, 9.169205665588379, 9.174165725708008, 9.177879333496094, 9.171126365661621, 9.168886184692383, 9.177526473999023, 9.169365882873535, 9.164726257324219, 9.163765907287598, 9.165817260742188, 9.164566040039062, 9.16744613647461, 9.168086051940918, 9.168086051940918], "compile_time": 666.0004570148885, "verification_time": 0, "benchmark_time": 295.0314227491617, "GFLOP/s": 823.0713160609204, "strategy_time": 0, "framework_time": 1.3649151660501957, "timestamp": "2023-12-21 11:12:03.336866+00:00"},
+"16,16,1,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.09870046377182, "times": [9.145364761352539, 9.109684944152832, 9.102484703063965, 9.09880542755127, 9.099285125732422, 9.094644546508789, 9.091073989868164, 9.09128475189209, 9.093846321105957, 9.319928169250488, 9.100565910339355, 9.09288501739502, 9.090165138244629, 9.090056419372559, 9.08792495727539, 9.085524559020996, 9.084404945373535, 9.085685729980469, 9.086484909057617, 9.082164764404297, 9.084328651428223, 9.085044860839844, 9.083925247192383, 9.082646369934082, 9.084885597229004, 9.084884643554688, 9.084884643554688, 9.085609436035156, 9.085844993591309, 9.08696460723877, 9.088725090026855, 9.08840560913086], "compile_time": 667.0912299305201, "verification_time": 0, "benchmark_time": 292.7176170051098, "GFLOP/s": 829.7610444547253, "strategy_time": 0, "framework_time": 1.3042483478784561, "timestamp": "2023-12-21 11:12:04.297995+00:00"},
+"16,16,1,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7611716017127037, "times": [1.8044960498809814, 1.7694560289382935, 1.764976978302002, 1.7644970417022705, 1.760817050933838, 1.763537049293518, 1.7648169994354248, 1.7585769891738892, 1.7574570178985596, 1.7596960067749023, 1.7604960203170776, 1.7574559450149536, 1.7579360008239746, 1.7616159915924072, 1.7579360008239746, 1.760817050933838, 1.757936954498291, 1.7617770433425903, 1.7603360414505005, 1.7580970525741577, 1.7598559856414795, 1.7576169967651367, 1.7571369409561157, 1.7566570043563843, 1.7556970119476318, 1.7590570449829102, 1.760336995124817, 1.7582570314407349, 1.7576169967651367, 1.7564959526062012, 1.7577760219573975, 1.758255958557129], "compile_time": 827.91061187163, "verification_time": 0, "benchmark_time": 57.92699707672, "GFLOP/s": 4286.775458256324, "strategy_time": 0, "framework_time": 1.4143520966172218, "timestamp": "2023-12-21 11:12:05.185263+00:00"},
+"16,16,1,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.17885035276413, "times": [9.21752643585205, 9.1820068359375, 9.175765991210938, 9.17624568939209, 9.188405990600586, 9.174165725708008, 9.17355728149414, 9.182966232299805, 9.174006462097168, 9.1735258102417, 9.166006088256836, 9.166325569152832, 9.16248607635498, 9.162184715270996, 9.166485786437988, 9.164566040039062, 9.166166305541992, 9.165205955505371, 9.421209335327148, 9.167125701904297, 9.165200233459473, 9.166646003723145, 9.166966438293457, 9.165205955505371, 9.163765907287598, 9.168405532836914, 9.170166015625, 9.165616035461426, 9.163926124572754, 9.169526100158691, 9.165366172790527, 9.166486740112305], "compile_time": 669.7353557683527, "verification_time": 0, "benchmark_time": 295.1991269364953, "GFLOP/s": 822.5155558535128, "strategy_time": 0, "framework_time": 1.3816403225064278, "timestamp": "2023-12-21 11:12:06.151595+00:00"},
+"16,16,1,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 1, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.089435875415802, "times": [9.14040470123291, 9.113365173339844, 9.114965438842773, 9.103925704956055, 9.095766067504883, 9.091126441955566, 9.090792655944824, 9.090004920959473, 9.08792495727539, 9.08344554901123, 9.0818452835083, 9.084725379943848, 9.08200454711914, 9.080731391906738, 9.08088493347168, 9.087124824523926, 9.085365295410156, 9.08792495727539, 9.085206031799316, 9.082646369934082, 9.082731246948242, 9.085524559020996, 9.082804679870605, 9.086165428161621, 9.084086418151855, 9.0839262008667, 9.087445259094238, 9.084982872009277, 9.083444595336914, 9.083765029907227, 9.08360481262207, 9.08328628540039], "compile_time": 653.5521037876606, "verification_time": 0, "benchmark_time": 292.41814743727446, "GFLOP/s": 830.6067949078998, "strategy_time": 0, "framework_time": 1.280872616916895, "timestamp": "2023-12-21 11:12:07.098860+00:00"},
+"16,16,2,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 5.80086287856102, "times": [5.849493980407715, 5.809974193572998, 5.800854206085205, 5.812854766845703, 5.687734127044678, 5.788373947143555, 5.682612895965576, 5.816854953765869, 5.7938151359558105, 5.805974960327148, 5.890439033508301, 5.8099751472473145, 5.8213348388671875, 5.790615081787109, 5.802454948425293, 5.90453577041626, 5.783575057983398, 5.641172885894775, 5.809013843536377, 5.666772842407227, 5.884214878082275, 5.804660797119141, 5.785974025726318, 5.81429386138916, 5.794134140014648, 5.801334857940674, 5.787095069885254, 6.003255844116211, 5.790133953094482, 5.782134056091309, 5.808373928070068, 5.803574085235596], "compile_time": 949.8916231095791, "verification_time": 0, "benchmark_time": 187.38018302246928, "GFLOP/s": 1301.486926695432, "strategy_time": 0, "framework_time": 1.3849237002432346, "timestamp": "2023-12-21 11:12:08.237533+00:00"},
+"16,16,2,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.470770627260208, "times": [9.528569221496582, 9.492729187011719, 9.481689453125, 9.478649139404297, 9.474489212036133, 9.46968936920166, 9.471019744873047, 9.46968936920166, 9.470488548278809, 9.467288970947266, 9.466328620910645, 9.466809272766113, 9.465688705444336, 9.465429306030273, 9.467449188232422, 9.466169357299805, 9.464248657226562, 9.46808910369873, 9.466009140014648, 9.467609405517578, 9.465949058532715, 9.465209007263184, 9.463448524475098, 9.46808910369873, 9.465848922729492, 9.466809272766113, 9.466809272766113, 9.464728355407715, 9.464729309082031, 9.466968536376953, 9.46808910369873, 9.4698486328125], "compile_time": 427.0905191078782, "verification_time": 0, "benchmark_time": 305.0398058257997, "GFLOP/s": 797.1629233918063, "strategy_time": 0, "framework_time": 1.4468040317296982, "timestamp": "2023-12-21 11:12:08.971126+00:00"},
+"16,16,2,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.43331304192543, "times": [9.483287811279297, 9.448409080505371, 9.439608573913574, 9.439929008483887, 9.43368911743164, 9.43384838104248, 9.434901237487793, 9.436248779296875, 9.431129455566406, 9.431609153747559, 9.428407669067383, 9.429207801818848, 9.428888320922852, 9.434614181518555, 9.428407669067383, 9.42936897277832, 9.428568840026855, 9.429048538208008, 9.433527946472168, 9.429368019104004, 9.434408187866211, 9.431129455566406, 9.428729057312012, 9.431769371032715, 9.42664909362793, 9.427127838134766, 9.429689407348633, 9.427291870117188, 9.4263277053833, 9.432888984680176, 9.42680835723877, 9.431129455566406], "compile_time": 428.04427864030004, "verification_time": 0, "benchmark_time": 303.51266311481595, "GFLOP/s": 800.3282798361395, "strategy_time": 0, "framework_time": 1.3672509230673313, "timestamp": "2023-12-21 11:12:09.704066+00:00"},
+"16,16,2,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7671964392066002, "times": [1.7988959550857544, 1.7702560424804688, 1.7620960474014282, 2.00593900680542, 1.7622560262680054, 1.7577760219573975, 1.7584160566329956, 1.7603360414505005, 1.765936017036438, 1.761296033859253, 1.756335973739624, 1.758255958557129, 1.756816029548645, 1.7571369409561157, 1.7576169967651367, 1.7564970254898071, 1.7572970390319824, 1.7564970254898071, 1.7552160024642944, 1.7552160024642944, 1.7592159509658813, 1.756816029548645, 1.7561759948730469, 1.7553759813308716, 1.755856990814209, 1.7550569772720337, 1.7571369409561157, 1.7587369680404663, 1.7572970390319824, 1.7552169561386108, 1.7558560371398926, 1.7574559450149536], "compile_time": 480.1285080611706, "verification_time": 0, "benchmark_time": 58.15234314650297, "GFLOP/s": 4272.160713151692, "strategy_time": 0, "framework_time": 1.3687331229448318, "timestamp": "2023-12-21 11:12:10.243730+00:00"},
+"16,16,2,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.468975961208344, "times": [9.519928932189941, 9.489370346069336, 9.478968620300293, 9.475448608398438, 9.477048873901367, 9.470329284667969, 9.472102165222168, 9.47240924835205, 9.470969200134277, 9.465688705444336, 9.463929176330566, 9.463129043579102, 9.464729309082031, 9.466068267822266, 9.463608741760254, 9.46536922454834, 9.465688705444336, 9.464089393615723, 9.467288970947266, 9.463608741760254, 9.46347713470459, 9.463129043579102, 9.465688705444336, 9.462808609008789, 9.46264934539795, 9.461528778076172, 9.46536922454834, 9.463410377502441, 9.46376895904541, 9.464408874511719, 9.463608741760254, 9.467609405517578], "compile_time": 422.6586688309908, "verification_time": 0, "benchmark_time": 305.02424389123917, "GFLOP/s": 797.3140106099256, "strategy_time": 0, "framework_time": 1.2994203716516495, "timestamp": "2023-12-21 11:12:10.972728+00:00"},
+"16,16,2,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.436830282211304, "times": [9.482168197631836, 9.455928802490234, 9.442487716674805, 9.449048042297363, 9.44328784942627, 9.441047668457031, 9.430623054504395, 9.430168151855469, 9.429048538208008, 9.422168731689453, 9.420409202575684, 9.42328929901123, 9.64841079711914, 9.42702865600586, 9.424089431762695, 9.434488296508789, 9.422167778015137, 9.42680835723877, 9.422968864440918, 9.432727813720703, 9.422143936157227, 9.42248821258545, 9.42248821258545, 9.421527862548828, 9.42184829711914, 9.42088794708252, 9.420727729797363, 9.42013931274414, 9.422167778015137, 9.424407958984375, 9.423768997192383, 9.427607536315918], "compile_time": 421.58346297219396, "verification_time": 0, "benchmark_time": 303.5177430137992, "GFLOP/s": 800.0299861523938, "strategy_time": 0, "framework_time": 1.3476242311298847, "timestamp": "2023-12-21 11:12:11.699192+00:00"},
+"16,16,2,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 7.616085857152939, "times": [7.63559103012085, 7.600070953369141, 7.660871982574463, 7.651432037353516, 7.5674309730529785, 7.636230945587158, 7.6208720207214355, 7.59111213684082, 7.632347106933594, 7.636551856994629, 7.638472080230713, 7.612872123718262, 7.652552127838135, 7.606791019439697, 7.63543176651001, 7.57879114151001, 7.625671863555908, 7.680988788604736, 7.613511085510254, 7.61735200881958, 7.575750827789307, 7.632552146911621, 7.580070972442627, 7.5562310218811035, 7.611751079559326, 7.618472099304199, 7.59405517578125, 7.641992092132568, 7.617671966552734, 7.598151206970215, 7.596551895141602, 7.596551895141602], "compile_time": 1893.848150037229, "verification_time": 0, "benchmark_time": 245.34972989931703, "GFLOP/s": 991.2896652693805, "strategy_time": 0, "framework_time": 1.3196980580687523, "timestamp": "2023-12-21 11:12:13.839725+00:00"},
+"16,16,2,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.176210701465607, "times": [9.222966194152832, 9.184406280517578, 9.177846908569336, 9.17448616027832, 9.171285629272461, 9.170806884765625, 9.172164916992188, 9.170486450195312, 9.167125701904297, 9.1735258102417, 9.171286582946777, 9.163286209106445, 9.166486740112305, 9.164331436157227, 9.173365592956543, 9.165045738220215, 9.162165641784668, 9.166485786437988, 9.162805557250977, 9.16136646270752, 9.161720275878906, 9.364567756652832, 9.165366172790527, 9.172085762023926, 9.16408634185791, 9.162325859069824, 9.177045822143555, 9.170912742614746, 9.16248607635498, 9.164727210998535, 9.165205955505371, 9.166485786437988], "compile_time": 704.9367278814316, "verification_time": 0, "benchmark_time": 295.01680471003056, "GFLOP/s": 822.7521626976338, "strategy_time": 0, "framework_time": 1.4393404126167297, "timestamp": "2023-12-21 11:12:14.841134+00:00"},
+"16,16,2,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.094990074634552, "times": [9.146644592285156, 9.114325523376465, 9.106486320495605, 9.102644920349121, 9.097845077514648, 9.10584545135498, 9.096283912658691, 9.096084594726562, 9.090484619140625, 9.091765403747559, 9.09528636932373, 9.090166091918945, 9.089044570922852, 9.090764045715332, 9.0885648727417, 9.089844703674316, 9.088885307312012, 9.088885307312012, 9.087446212768555, 9.090485572814941, 9.096837043762207, 9.09288501739502, 9.088725090026855, 9.093364715576172, 9.091285705566406, 9.08936595916748, 9.093206405639648, 9.092447280883789, 9.090165138244629, 9.088404655456543, 9.087285995483398, 9.087925910949707], "compile_time": 708.6004302836955, "verification_time": 0, "benchmark_time": 292.46956622228026, "GFLOP/s": 830.0995534954839, "strategy_time": 0, "framework_time": 1.4421343803405762, "timestamp": "2023-12-21 11:12:15.843661+00:00"},
+"16,16,2,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.737641278654337, "times": [1.772495985031128, 1.7416160106658936, 1.733456015586853, 1.7344169616699219, 1.7310559749603271, 1.7312159538269043, 1.7294559478759766, 1.73089599609375, 1.7280160188674927, 1.7278560400009155, 1.7297760248184204, 1.7291359901428223, 1.7292959690093994, 1.728816032409668, 1.7323369979858398, 1.7289769649505615, 1.7275359630584717, 1.731376051902771, 1.7299360036849976, 1.7291359901428223, 1.7297769784927368, 1.732975959777832, 1.728335976600647, 1.7300959825515747, 1.7286570072174072, 1.7313770055770874, 1.7289760112762451, 1.7280160188674927, 1.726896047592163, 1.7275370359420776, 1.9201780557632446, 1.734895944595337], "compile_time": 839.8883217014372, "verification_time": 0, "benchmark_time": 57.57603561505675, "GFLOP/s": 4344.824960561866, "strategy_time": 0, "framework_time": 1.4422666281461716, "timestamp": "2023-12-21 11:12:16.742584+00:00"},
+"16,16,2,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.16522428393364, "times": [9.210165977478027, 9.179925918579102, 9.172086715698242, 9.16744613647461, 9.165046691894531, 9.169205665588379, 9.1613130569458, 9.159605979919434, 9.173686027526855, 9.162165641784668, 9.158966064453125, 9.162325859069824, 9.15976619720459, 9.162446022033691, 9.164566040039062, 9.163765907287598, 9.167125701904297, 9.161046028137207, 9.164886474609375, 9.15976619720459, 9.160685539245605, 9.159126281738281, 9.16408634185791, 9.158645629882812, 9.165205955505371, 9.160566329956055, 9.158805847167969, 9.160002708435059, 9.17448616027832, 9.160566329956055, 9.159605979919434, 9.160085678100586], "compile_time": 700.169526040554, "verification_time": 0, "benchmark_time": 294.6356148459017, "GFLOP/s": 823.7384013869117, "strategy_time": 0, "framework_time": 1.2650121934711933, "timestamp": "2023-12-21 11:12:17.738669+00:00"},
+"16,16,2,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.094926595687866, "times": [9.144084930419922, 9.108724594116211, 9.102485656738281, 9.102165222167969, 9.0983247756958, 9.100886344909668, 9.094193458557129, 9.093045234680176, 9.08952522277832, 9.094644546508789, 9.089844703674316, 9.089204788208008, 9.090326309204102, 9.089983940124512, 9.089844703674316, 9.090165138244629, 9.092564582824707, 9.08936595916748, 9.0936861038208, 9.099286079406738, 9.089487075805664, 9.089844703674316, 9.09128475189209, 9.089204788208008, 9.094965934753418, 9.089205741882324, 9.089845657348633, 9.090719223022461, 9.09288501739502, 9.096244812011719, 9.089204788208008, 9.092406272888184], "compile_time": 699.0684908814728, "verification_time": 0, "benchmark_time": 292.5279689952731, "GFLOP/s": 830.1053472580553, "strategy_time": 0, "framework_time": 1.3187169097363949, "timestamp": "2023-12-21 11:12:18.731599+00:00"},
+"16,16,2,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.64454650878906, "times": [32.7311897277832, 34.01340103149414, 33.70223617553711, 33.92012023925781, 33.80704116821289, 34.12458419799805, 33.904319763183594, 33.63059616088867, 33.641117095947266, 33.949249267578125, 33.07935333251953, 34.01307678222656, 33.5886344909668, 33.931758880615234, 33.301910400390625, 33.818450927734375, 34.06671905517578, 33.47208786010742, 33.79328155517578, 34.02415084838867, 33.957279205322266, 33.924312591552734, 32.95246887207031, 34.03284454345703, 32.850067138671875, 33.11178970336914, 33.359352111816406, 33.4927864074707, 33.85776138305664, 33.97952651977539, 33.88639831542969, 32.70762252807617], "compile_time": 1742.583611048758, "verification_time": 0, "benchmark_time": 1078.2907139509916, "GFLOP/s": 224.39735361056975, "strategy_time": 0, "framework_time": 1.3164528645575047, "timestamp": "2023-12-21 11:12:21.553805+00:00"},
+"16,16,2,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.511809527873993, "times": [21.763084411621094, 21.527563095092773, 21.49720001220703, 21.64804458618164, 21.561962127685547, 21.804859161376953, 21.45844268798828, 21.39620018005371, 21.458667755126953, 21.475881576538086, 21.60596466064453, 21.811111450195312, 21.305320739746094, 21.734283447265625, 21.586456298828125, 21.552204132080078, 21.413482666015625, 21.249595642089844, 21.37347984313965, 21.903886795043945, 21.398014068603516, 21.585163116455078, 21.309160232543945, 21.422588348388672, 21.2691593170166, 21.36035919189453, 21.462495803833008, 21.586763381958008, 21.67988395690918, 21.46694564819336, 21.39299964904785, 21.316680908203125], "compile_time": 1342.0234420336783, "verification_time": 0, "benchmark_time": 689.9389429017901, "GFLOP/s": 350.9582580776104, "strategy_time": 0, "framework_time": 1.4103339053690434, "timestamp": "2023-12-21 11:12:23.587199+00:00"},
+"16,16,2,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.472995221614838, "times": [21.370759963989258, 21.66452407836914, 21.39836883544922, 21.441322326660156, 21.469322204589844, 21.44525909423828, 21.405960083007812, 21.313640594482422, 21.496484756469727, 21.391239166259766, 21.86980438232422, 21.657272338867188, 21.43956184387207, 21.564523696899414, 21.195438385009766, 21.585803985595703, 21.746604919433594, 21.390291213989258, 21.51508140563965, 21.285160064697266, 21.384538650512695, 21.711244583129883, 21.503562927246094, 21.35799217224121, 21.413799285888672, 21.377159118652344, 21.513673782348633, 21.51108169555664, 21.498281478881836, 21.504728317260742, 21.227720260620117, 21.485641479492188], "compile_time": 1302.725920919329, "verification_time": 0, "benchmark_time": 688.6640419252217, "GFLOP/s": 351.5926456501225, "strategy_time": 0, "framework_time": 1.3966867700219154, "timestamp": "2023-12-21 11:12:25.580001+00:00"},
+"16,16,2,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 32.74637418985367, "times": [32.39534378051758, 33.01465606689453, 32.47342300415039, 32.88278579711914, 32.016780853271484, 32.84145736694336, 32.67662811279297, 33.01908493041992, 33.56703567504883, 32.4678955078125, 33.16127014160156, 32.80083465576172, 33.08287048339844, 32.91798400878906, 32.769588470458984, 32.706260681152344, 33.01327133178711, 32.21250534057617, 32.32126235961914, 32.34458923339844, 33.1204719543457, 32.36471176147461, 33.00735092163086, 32.983882904052734, 31.972620010375977, 32.19900131225586, 33.16399383544922, 32.34849166870117, 33.251670837402344, 33.078155517578125, 33.1487922668457, 32.559303283691406], "compile_time": 1944.3784169852734, "verification_time": 0, "benchmark_time": 1049.440366216004, "GFLOP/s": 230.55215689617503, "strategy_time": 0, "framework_time": 1.4842869713902473, "timestamp": "2023-12-21 11:12:28.575319+00:00"},
+"16,16,2,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.510995507240295, "times": [21.92436408996582, 21.485641479492188, 21.619579315185547, 21.174440383911133, 21.227399826049805, 21.47263526916504, 21.584203720092773, 21.774444580078125, 21.543624877929688, 21.540361404418945, 21.50884246826172, 21.3675479888916, 21.426279067993164, 21.50484275817871, 21.547218322753906, 21.811084747314453, 21.385799407958984, 21.75659942626953, 21.54804229736328, 21.50788116455078, 21.4173641204834, 21.33300018310547, 21.42371940612793, 21.56452751159668, 21.48436164855957, 21.667724609375, 21.30194091796875, 21.691083908081055, 21.670124053955078, 21.4632568359375, 21.28067970275879, 21.34324073791504], "compile_time": 1340.3562498278916, "verification_time": 0, "benchmark_time": 689.8315651342273, "GFLOP/s": 350.9715390651661, "strategy_time": 0, "framework_time": 1.3388749212026596, "timestamp": "2023-12-21 11:12:30.606861+00:00"},
+"16,16,2,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.507807195186615, "times": [21.919883728027344, 21.440200805664062, 21.589637756347656, 21.59412384033203, 21.590604782104492, 21.42283821105957, 21.436359405517578, 21.336519241333008, 21.545188903808594, 21.55924415588379, 21.470121383666992, 21.320180892944336, 21.85060691833496, 21.414440155029297, 21.370664596557617, 21.43876075744629, 21.38163948059082, 21.645343780517578, 21.565324783325195, 21.465322494506836, 21.438936233520508, 21.18899917602539, 21.40675926208496, 21.665746688842773, 21.48436164855957, 21.682443618774414, 21.362987518310547, 21.52372169494629, 21.755083084106445, 21.49042320251465, 21.431880950927734, 21.46148109436035], "compile_time": 1315.0812918320298, "verification_time": 0, "benchmark_time": 689.8939060047269, "GFLOP/s": 351.0235669998758, "strategy_time": 0, "framework_time": 1.4116670936346054, "timestamp": "2023-12-21 11:12:32.613262+00:00"},
+"16,16,2,4,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 6.204050540924072, "times": [6.2731781005859375, 6.214777946472168, 6.203258037567139, 6.204217910766602, 6.1997389793396, 6.2474188804626465, 6.182938098907471, 6.2486982345581055, 6.201979160308838, 6.199676036834717, 6.1848578453063965, 6.208539009094238, 6.22213888168335, 6.200538158416748, 6.185177803039551, 6.195097923278809, 6.223099231719971, 6.193818092346191, 6.183897972106934, 6.223099231719971, 6.217018127441406, 6.211578845977783, 6.178458213806152, 6.193498134613037, 6.181979179382324, 6.177018165588379, 6.152698040008545, 6.216538906097412, 6.226139068603516, 6.171098232269287, 6.224668979644775, 6.1827778816223145], "compile_time": 1086.9892677292228, "verification_time": 0, "benchmark_time": 200.05809795111418, "GFLOP/s": 1216.906140625265, "strategy_time": 0, "framework_time": 1.505478285253048, "timestamp": "2023-12-21 11:12:33.901831+00:00"},
+"16,16,2,4,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.228614091873169, "times": [9.267926216125488, 9.482969284057617, 9.232247352600098, 9.231125831604004, 9.223926544189453, 9.219447135925293, 9.21712875366211, 9.218807220458984, 9.218807220458984, 9.21800708770752, 9.218167304992676, 9.21896743774414, 9.223127365112305, 9.219002723693848, 9.220406532287598, 9.21640682220459, 9.21464729309082, 9.214166641235352, 9.225847244262695, 9.221205711364746, 9.215495109558105, 9.213847160339355, 9.214166641235352, 9.216567039489746, 9.220406532287598, 9.216727256774902, 9.215126991271973, 9.216629028320312, 9.21480655670166, 9.214966773986816, 9.21896743774414, 9.215606689453125], "compile_time": 1499.165665358305, "verification_time": 0, "benchmark_time": 296.88377398997545, "GFLOP/s": 818.0802799684083, "strategy_time": 0, "framework_time": 1.366298645734787, "timestamp": "2023-12-21 11:12:35.699262+00:00"},
+"16,16,2,4,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 4, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.147145092487335, "times": [9.198486328125, 9.165045738220215, 9.155606269836426, 9.160086631774902, 9.158326148986816, 9.152726173400879, 9.149699211120605, 9.144725799560547, 9.144085884094238, 9.142966270446777, 9.147605895996094, 9.14168643951416, 9.140405654907227, 9.139653205871582, 9.141205787658691, 9.141205787658691, 9.143125534057617, 9.141204833984375, 9.141526222229004, 9.142485618591309, 9.141996383666992, 9.141045570373535, 9.141044616699219, 9.149685859680176, 9.14632511138916, 9.143285751342773, 9.140564918518066, 9.140972137451172, 9.144725799560547, 9.141366004943848, 9.142806053161621, 9.142965316772461], "compile_time": 1497.3348560743034, "verification_time": 0, "benchmark_time": 294.5687351748347, "GFLOP/s": 825.3665076550171, "strategy_time": 0, "framework_time": 1.4736666344106197, "timestamp": "2023-12-21 11:12:37.492655+00:00"},
+"16,16,2,4,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 1.7934017814695835, "times": [1.8248159885406494, 1.7961770296096802, 1.784337043762207, 1.7886569499969482, 1.7851359844207764, 1.7822569608688354, 1.785936951637268, 1.7793769836425781, 1.7993769645690918, 1.7808170318603516, 2.0033791065216064, 1.7878570556640625, 1.7944170236587524, 1.7899370193481445, 1.7777760028839111, 1.7819370031356812, 1.797456979751587, 1.786417007446289, 1.7865769863128662, 1.7825770378112793, 1.7876969575881958, 1.783216953277588, 1.781296968460083, 1.7792160511016846, 1.780176043510437, 1.7833759784698486, 1.793455958366394, 1.785776972770691, 1.7686560153961182, 1.7836970090866089, 1.7835359573364258, 1.7835370302200317], "compile_time": 1682.9056800343096, "verification_time": 0, "benchmark_time": 58.78371698781848, "GFLOP/s": 4209.735530547673, "strategy_time": 0, "framework_time": 1.43330916762352, "timestamp": "2023-12-21 11:12:39.235792+00:00"},
+"16,16,2,4,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.214958816766739, "times": [9.264725685119629, 9.233846664428711, 9.224246978759766, 9.222806930541992, 9.220406532287598, 9.214166641235352, 9.214380264282227, 9.2136869430542, 9.212246894836426, 9.210967063903809, 9.2103271484375, 9.210006713867188, 9.211285591125488, 9.211199760437012, 9.209047317504883, 9.213847160339355, 9.212726593017578, 9.212886810302734, 9.210487365722656, 9.2116060256958, 9.211176872253418, 9.208566665649414, 9.209366798400879, 9.21464729309082, 9.21304702758789, 9.21320629119873, 9.211285591125488, 9.21069622039795, 9.209527015686035, 9.210967063903809, 9.210487365722656, 9.210806846618652], "compile_time": 1480.1185000687838, "verification_time": 0, "benchmark_time": 296.6759097762406, "GFLOP/s": 819.2925600777658, "strategy_time": 0, "framework_time": 1.389164011925459, "timestamp": "2023-12-21 11:12:41.013991+00:00"},
+"16,16,2,4,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 2, "tile_size_y": 4, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 9.149962365627289, "times": [9.19096565246582, 9.158005714416504, 9.15784740447998, 9.146326065063477, 9.146645545959473, 9.142966270446777, 9.141535758972168, 9.141205787658691, 9.14168643951416, 9.142806053161621, 9.137845993041992, 9.14008617401123, 9.141045570373535, 9.14298152923584, 9.139925956726074, 9.139286041259766, 9.139765739440918, 9.138965606689453, 9.138006210327148, 9.358967781066895, 9.144369125366211, 9.141366004943848, 9.138806343078613, 9.140565872192383, 9.139286041259766, 9.139286041259766, 9.13928508758545, 9.139660835266113, 9.137045860290527, 9.13576602935791, 9.138965606689453, 9.13752555847168], "compile_time": 1478.7978907115757, "verification_time": 0, "benchmark_time": 294.65309903025627, "GFLOP/s": 825.1123773318839, "strategy_time": 0, "framework_time": 1.4002053067088127, "timestamp": "2023-12-21 11:12:42.788858+00:00"},
+"16,16,3,1,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.31586956977844, "times": [34.27920150756836, 34.30155944824219, 34.35680389404297, 34.1385612487793, 34.300323486328125, 34.39279556274414, 34.13888168334961, 34.35960006713867, 34.25727844238281, 34.38970947265625, 34.28752136230469, 34.509246826171875, 34.46672439575195, 34.342647552490234, 34.639366149902344, 34.323062896728516, 34.48784255981445, 34.09661102294922, 34.21984100341797, 34.090423583984375, 34.564002990722656, 33.59653091430664, 34.16463851928711, 34.589969635009766, 34.33760452270508, 33.947608947753906, 33.95296096801758, 34.855072021484375, 34.13983917236328, 34.47394943237305, 34.64496612548828, 34.46268081665039], "compile_time": 2380.113825201988, "verification_time": 0, "benchmark_time": 1099.7308688238263, "GFLOP/s": 220.007457035242, "strategy_time": 0, "framework_time": 1.4096219092607498, "timestamp": "2023-12-21 11:12:46.270129+00:00"},
+"16,16,3,1,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.241104781627655, "times": [15.27038288116455, 15.284783363342285, 15.284942626953125, 15.415024757385254, 15.20166015625, 15.241263389587402, 15.186541557312012, 15.255023002624512, 15.191502571105957, 15.316900253295898, 15.38078498840332, 15.25710391998291, 15.30174446105957, 15.206382751464844, 15.369182586669922, 15.272303581237793, 15.185422897338867, 15.199342727661133, 15.348943710327148, 15.24825668334961, 15.131341934204102, 15.03214168548584, 15.187663078308105, 15.154382705688477, 15.206743240356445, 15.222382545471191, 15.1617431640625, 15.2031831741333, 15.540785789489746, 15.164729118347168, 15.154541969299316, 15.138221740722656], "compile_time": 548.8235792145133, "verification_time": 0, "benchmark_time": 489.3771577626467, "GFLOP/s": 495.3543268792968, "strategy_time": 0, "framework_time": 1.4531360939145088, "timestamp": "2023-12-21 11:12:47.309798+00:00"},
+"16,16,3,1,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 1, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.194027096033096, "times": [15.23758316040039, 15.369424819946289, 15.213262557983398, 15.09598159790039, 15.191821098327637, 15.35838508605957, 15.125262260437012, 15.213262557983398, 15.023820877075195, 15.233430862426758, 15.294544219970703, 15.223023414611816, 15.241904258728027, 15.17822265625, 15.074647903442383, 15.1380615234375, 15.126062393188477, 15.050862312316895, 15.161903381347656, 15.260849952697754, 15.240623474121094, 15.181742668151855, 15.288304328918457, 15.127983093261719, 15.256166458129883, 15.132942199707031, 15.062220573425293, 15.160621643066406, 15.191822052001953, 15.267597198486328, 15.168462753295898, 15.318063735961914], "compile_time": 552.0363082177937, "verification_time": 0, "benchmark_time": 487.7752219326794, "GFLOP/s": 496.88914941918927, "strategy_time": 0, "framework_time": 2.0505348220467567, "timestamp": "2023-12-21 11:12:48.351675+00:00"},
+"16,16,3,1,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 34.11150097846985, "times": [34.31216049194336, 33.78526306152344, 34.174560546875, 33.92732238769531, 34.31200408935547, 34.09625244140625, 33.66111755371094, 34.2518424987793, 33.991519927978516, 34.24128341674805, 34.24176025390625, 34.304527282714844, 34.03184127807617, 34.15669250488281, 33.814720153808594, 34.225257873535156, 34.442562103271484, 33.9580078125, 34.12223815917969, 34.18178176879883, 33.80112075805664, 34.1147575378418, 34.350242614746094, 34.40162658691406, 34.27872085571289, 34.18086242675781, 33.720794677734375, 33.51912307739258, 34.376163482666016, 34.24117660522461, 34.02463912963867, 34.326087951660156], "compile_time": 4668.491658754647, "verification_time": 0, "benchmark_time": 1093.1280707009137, "GFLOP/s": 221.32556420678094, "strategy_time": 0, "framework_time": 1.548441592603922, "timestamp": "2023-12-21 11:12:54.114858+00:00"},
+"16,16,3,1,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.308500200510025, "times": [15.382224082946777, 15.230063438415527, 15.381264686584473, 15.297743797302246, 15.362344741821289, 15.499826431274414, 15.31982421875, 15.404945373535156, 15.20222282409668, 15.316597938537598, 15.392464637756348, 15.27086353302002, 15.285103797912598, 15.21086311340332, 15.243947982788086, 15.274383544921875, 15.22030258178711, 15.367823600769043, 15.36894416809082, 15.329739570617676, 15.344783782958984, 15.377264976501465, 15.245583534240723, 15.292783737182617, 15.270934104919434, 15.251182556152344, 15.287022590637207, 15.365584373474121, 15.321743965148926, 15.127420425415039, 15.408945083618164, 15.217263221740723], "compile_time": 549.4297207333148, "verification_time": 0, "benchmark_time": 491.46729800850153, "GFLOP/s": 493.1735376499175, "strategy_time": 0, "framework_time": 1.4892863109707832, "timestamp": "2023-12-21 11:12:55.157261+00:00"},
+"16,16,3,1,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 1, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 15.199373066425323, "times": [15.210062026977539, 15.132302284240723, 15.083980560302734, 15.213262557983398, 15.22321891784668, 15.198542594909668, 15.155182838439941, 15.170381546020508, 15.18750286102295, 15.124090194702148, 15.223342895507812, 15.26942253112793, 15.240463256835938, 15.165903091430664, 15.064152717590332, 15.208943367004395, 15.280142784118652, 15.1900634765625, 15.119662284851074, 15.254535675048828, 15.14670181274414, 15.305103302001953, 15.229582786560059, 15.146223068237305, 15.172468185424805, 15.36302375793457, 15.172942161560059, 15.159823417663574, 15.15918254852295, 15.23104190826416, 15.17678165435791, 15.401905059814453], "compile_time": 552.1397539414465, "verification_time": 0, "benchmark_time": 488.00355289131403, "GFLOP/s": 496.7143820344159, "strategy_time": 0, "framework_time": 1.43499206751585, "timestamp": "2023-12-21 11:12:56.198854+00:00"},
+"16,16,3,2,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.69733476638794, "times": [33.654876708984375, 33.598628997802734, 33.813438415527344, 33.99969482421875, 33.2235107421875, 34.31106185913086, 34.07600021362305, 33.679443359375, 33.314231872558594, 34.01870346069336, 34.12303924560547, 34.30906677246094, 34.0494384765625, 33.944183349609375, 34.581764221191406, 33.06107711791992, 33.50607681274414, 33.41733169555664, 34.35728454589844, 33.31480026245117, 33.472312927246094, 33.412654876708984, 34.26559829711914, 33.340606689453125, 33.8779182434082, 33.854888916015625, 33.1369514465332, 33.56779098510742, 33.3609504699707, 33.67604446411133, 33.015350341796875, 32.9799919128418], "compile_time": 1677.0929601043463, "verification_time": 0, "benchmark_time": 1079.9597441218793, "GFLOP/s": 224.04582594854477, "strategy_time": 0, "framework_time": 1.3399766758084297, "timestamp": "2023-12-21 11:12:58.957261+00:00"},
+"16,16,3,2,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.740345239639282, "times": [21.854284286499023, 21.608844757080078, 21.68667221069336, 21.880525588989258, 21.777803421020508, 21.6937313079834, 21.578283309936523, 21.655723571777344, 21.946521759033203, 21.940845489501953, 21.771244049072266, 21.979019165039062, 21.742284774780273, 21.600364685058594, 21.780908584594727, 21.912525177001953, 21.792043685913086, 21.722749710083008, 21.5374813079834, 22.009647369384766, 21.684825897216797, 21.545164108276367, 21.740524291992188, 21.741100311279297, 21.89508628845215, 21.66180419921875, 21.545040130615234, 21.753963470458984, 21.55364227294922, 21.53350067138672, 21.861806869506836, 21.70308494567871], "compile_time": 1387.7069186419249, "verification_time": 0, "benchmark_time": 697.3454938270152, "GFLOP/s": 347.26896545481287, "strategy_time": 0, "framework_time": 1.3965675607323647, "timestamp": "2023-12-21 11:13:01.043725+00:00"},
+"16,16,3,2,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 2, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.685631811618805, "times": [21.664043426513672, 22.085647583007812, 21.89982032775879, 21.473482131958008, 21.54580307006836, 21.598800659179688, 21.619243621826172, 21.804044723510742, 21.848983764648438, 21.67876434326172, 21.564523696899414, 21.52036476135254, 21.88660430908203, 21.90372657775879, 21.678171157836914, 22.012367248535156, 21.527881622314453, 21.654619216918945, 21.579723358154297, 21.495882034301758, 21.840526580810547, 21.701644897460938, 21.41476058959961, 21.780902862548828, 21.556203842163086, 21.597963333129883, 21.731191635131836, 21.68100357055664, 21.637163162231445, 21.7751522064209, 21.60836410522461, 21.572843551635742], "compile_time": 1270.2341419644654, "verification_time": 0, "benchmark_time": 695.3239548020065, "GFLOP/s": 348.14513432599045, "strategy_time": 0, "framework_time": 1.4296812005341053, "timestamp": "2023-12-21 11:13:03.010728+00:00"},
+"16,16,3,2,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 33.101682305336, "times": [33.39455032348633, 33.012569427490234, 33.057430267333984, 33.16429901123047, 32.79182815551758, 33.114768981933594, 32.649269104003906, 33.07447814941406, 32.595027923583984, 33.161617279052734, 33.44143295288086, 33.28995895385742, 32.59870910644531, 32.98375701904297, 33.21839141845703, 32.967220306396484, 33.22479248046875, 33.4774284362793, 33.43167495727539, 33.07613754272461, 33.62287521362305, 33.23711395263672, 33.69743728637695, 33.45595932006836, 32.8790283203125, 32.96892166137695, 32.570865631103516, 32.74931335449219, 32.63326644897461, 33.3747673034668, 33.178871154785156, 33.160072326660156], "compile_time": 1890.7147678546607, "verification_time": 0, "benchmark_time": 1060.9696102328598, "GFLOP/s": 228.07744725357895, "strategy_time": 0, "framework_time": 1.3712774962186813, "timestamp": "2023-12-21 11:13:05.963799+00:00"},
+"16,16,3,2,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.749958395957947, "times": [21.69444465637207, 21.814603805541992, 22.006616592407227, 21.565004348754883, 21.88132667541504, 22.031675338745117, 21.652524948120117, 22.08148765563965, 21.861295700073242, 22.0806884765625, 21.783723831176758, 21.6910457611084, 21.750123977661133, 21.648204803466797, 21.564817428588867, 21.658443450927734, 21.785324096679688, 21.746896743774414, 21.83428382873535, 21.753803253173828, 21.44835662841797, 21.637964248657227, 21.631723403930664, 21.528972625732422, 21.6229248046875, 21.828365325927734, 21.77404022216797, 21.545001983642578, 21.941646575927734, 21.93484878540039, 21.670124053955078, 21.548364639282227], "compile_time": 1269.3452979438007, "verification_time": 0, "benchmark_time": 697.4945031106472, "GFLOP/s": 347.11547776583603, "strategy_time": 0, "framework_time": 1.471221912652254, "timestamp": "2023-12-21 11:13:07.932126+00:00"},
+"16,16,3,2,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 2, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 21.702042758464813, "times": [22.15924835205078, 21.570924758911133, 21.666709899902344, 21.63348388671875, 21.681804656982422, 21.953941345214844, 21.588523864746094, 21.991567611694336, 21.62830352783203, 21.41588020324707, 21.944686889648438, 21.73053741455078, 21.774124145507812, 21.649803161621094, 21.777910232543945, 21.827404022216797, 21.701004028320312, 21.489208221435547, 21.601964950561523, 21.777484893798828, 21.48160743713379, 21.910446166992188, 21.724523544311523, 21.682537078857422, 21.369159698486328, 21.489322662353516, 21.87044906616211, 21.880205154418945, 21.481002807617188, 21.710229873657227, 21.622283935546875, 21.67908477783203], "compile_time": 1254.4136820361018, "verification_time": 0, "benchmark_time": 696.0225789807737, "GFLOP/s": 347.88186918741764, "strategy_time": 0, "framework_time": 1.417418010532856, "timestamp": "2023-12-21 11:13:09.883995+00:00"},
+"16,16,3,3,0,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 41.66952967643738, "times": [42.20231628417969, 41.203956604003906, 41.204708099365234, 42.27112579345703, 41.10502624511719, 42.25605010986328, 42.33287811279297, 41.121456146240234, 41.727752685546875, 41.21031951904297, 41.18982696533203, 41.12492752075195, 42.4168815612793, 42.04056167602539, 42.44200134277344, 42.429168701171875, 41.28854751586914, 42.086631774902344, 42.36423873901367, 42.17822265625, 41.6197509765625, 41.2161750793457, 40.851905822753906, 40.797672271728516, 41.74119186401367, 42.3004150390625, 41.81751251220703, 42.20127868652344, 40.957664489746094, 41.5733757019043, 41.28534698486328, 40.86606216430664], "compile_time": 2627.283117733896, "verification_time": 0, "benchmark_time": 1335.158911999315, "GFLOP/s": 181.18148341542505, "strategy_time": 0, "framework_time": 1.4107241295278072, "timestamp": "2023-12-21 11:13:13.847864+00:00"},
+"16,16,3,3,0,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 25.61543434858322, "times": [27.255775451660156, 26.432567596435547, 26.41405487060547, 26.368087768554688, 26.36456871032715, 25.889568328857422, 25.515600204467773, 25.244396209716797, 25.323562622070312, 25.638959884643555, 25.495920181274414, 25.367080688476562, 25.45128059387207, 25.424400329589844, 25.431224822998047, 25.440879821777344, 25.393840789794922, 25.56254005432129, 25.44215965270996, 25.306318283081055, 25.353845596313477, 25.292877197265625, 25.470319747924805, 25.508119583129883, 25.36935806274414, 25.419279098510742, 25.418455123901367, 25.400880813598633, 25.34040069580078, 25.340295791625977, 25.45368003845215, 25.563600540161133], "compile_time": 2693.5551399365067, "verification_time": 0, "benchmark_time": 821.1452658288181, "GFLOP/s": 294.734303438332, "strategy_time": 0, "framework_time": 1.482484396547079, "timestamp": "2023-12-21 11:13:17.364062+00:00"},
+"16,16,3,3,0,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 3, "read_only": 0, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 24.8501455783844, "times": [25.34375762939453, 24.934316635131836, 24.775108337402344, 24.731271743774414, 24.720552444458008, 24.815731048583984, 24.876394271850586, 24.55415153503418, 24.741867065429688, 24.961196899414062, 24.7845516204834, 24.809404373168945, 24.86599349975586, 24.968076705932617, 24.934602737426758, 25.052555084228516, 24.64423179626465, 24.749683380126953, 24.776552200317383, 24.810474395751953, 24.989648818969727, 24.767911911010742, 25.083595275878906, 24.819547653198242, 24.757831573486328, 24.854633331298828, 24.865732192993164, 24.60967254638672, 25.045196533203125, 24.71434783935547, 25.163915634155273, 24.682151794433594], "compile_time": 2482.0166397839785, "verification_time": 0, "benchmark_time": 796.9666258431971, "GFLOP/s": 303.8109847761639, "strategy_time": 0, "framework_time": 1.412858720868826, "timestamp": "2023-12-21 11:13:20.644473+00:00"},
+"16,16,3,3,1,0,0,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 0, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 41.24126327037811, "times": [42.275596618652344, 41.40294647216797, 40.8488655090332, 41.35508728027344, 42.799922943115234, 41.72520065307617, 40.92326354980469, 40.73954772949219, 42.040557861328125, 40.27140808105469, 41.95463562011719, 40.51007080078125, 41.2768669128418, 40.67252731323242, 41.940391540527344, 42.70308303833008, 41.324546813964844, 40.299320220947266, 40.837982177734375, 40.485801696777344, 40.333980560302734, 40.419559478759766, 41.47911071777344, 40.88568878173828, 40.19125747680664, 40.37665939331055, 42.260555267333984, 42.36266326904297, 41.20038986206055, 41.05043411254883, 42.541038513183594, 40.23146438598633], "compile_time": 3236.433010082692, "verification_time": 0, "benchmark_time": 1321.208467707038, "GFLOP/s": 183.06294718723296, "strategy_time": 0, "framework_time": 1.4778454788029194, "timestamp": "2023-12-21 11:13:25.203608+00:00"},
+"16,16,3,3,1,0,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 0, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 25.346384942531586, "times": [25.42327880859375, 25.30487823486328, 25.504884719848633, 25.396560668945312, 25.314477920532227, 25.50745964050293, 25.423599243164062, 25.27063751220703, 25.280813217163086, 25.368879318237305, 25.41320037841797, 25.31989860534668, 25.27383804321289, 25.23399543762207, 25.33621597290039, 25.20103645324707, 25.29399871826172, 25.25699806213379, 25.351757049560547, 25.27143669128418, 25.321640014648438, 25.323917388916016, 25.38199806213379, 25.419387817382812, 25.274797439575195, 25.277517318725586, 25.607574462890625, 25.27735710144043, 25.35767936706543, 25.505807876586914, 25.336078643798828, 25.252717971801758], "compile_time": 2442.002099007368, "verification_time": 0, "benchmark_time": 812.7027512528002, "GFLOP/s": 297.8628793462147, "strategy_time": 0, "framework_time": 1.4541386626660824, "timestamp": "2023-12-21 11:13:28.459783+00:00"},
+"16,16,3,3,1,1,1,1,15,15": {"block_size_x": 16, "block_size_y": 16, "tile_size_x": 3, "tile_size_y": 3, "read_only": 1, "use_padding": 1, "use_shmem": 1, "use_cmem": 1, "filter_height": 15, "filter_width": 15, "time": 24.850156247615814, "times": [24.627111434936523, 24.859272003173828, 24.924835205078125, 24.68343162536621, 24.844234466552734, 24.86811637878418, 24.973356246948242, 24.731752395629883, 24.721420288085938, 24.65831184387207, 24.805513381958008, 24.989927291870117, 24.66583251953125, 25.14215660095215, 25.107667922973633, 24.7427921295166, 24.85223388671875, 25.077896118164062, 24.880393981933594, 24.903593063354492, 24.772567749023438, 24.763912200927734, 24.704551696777344, 24.598020553588867, 24.621192932128906, 24.83495330810547, 25.273080825805664, 25.105195999145508, 24.848073959350586, 24.94233512878418, 24.81319236755371, 24.868074417114258], "compile_time": 2632.5526130385697, "verification_time": 0, "benchmark_time": 796.842613723129, "GFLOP/s": 303.81085433715697, "strategy_time": 0, "framework_time": 1.259753480553627, "timestamp": "2023-12-21 11:13:31.890452+00:00"}
+}
+}
diff --git a/test/test_cache_files/small_cache.json b/test/test_cache_files/small_cache.json
new file mode 100644
index 000000000..f3923a03f
--- /dev/null
+++ b/test/test_cache_files/small_cache.json
@@ -0,0 +1,28 @@
+{
+"schema_version": "1.0.0",
+"device_name": "Testing",
+"kernel_name": "convolution_kernel",
+"problem_size": [
+4096,
+4096
+],
+"tune_params_keys": [
+"block_size_x",
+"block_size_y"
+],
+"tune_params": {
+"block_size_x": [
+16,
+32
+],
+"block_size_y": [
+1,
+2
+]
+},
+"objective": "time",
+"cache": {
+"16,1": {"block_size_x": 16, "block_size_y": 1, "time": 3.8753279224038124, "times": [3.976191997528076, 3.8789119720458984, 3.872767925262451, 3.872767925262451, 3.8737919330596924, 3.8737919330596924, 3.872767925262451, 3.87174391746521, 3.872767925262451, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.872767925262451, 3.87174391746521, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.8696959018707275, 3.872767925262451, 3.8707199096679688, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.872767925262451, 3.872767925262451, 3.8707199096679688, 3.872767925262451, 3.8707199096679688], "compile_time": 918.5990339610726, "verification_time": 0, "benchmark_time": 126.3829180970788, "GFLOP/s": 1948.1569950129526, "strategy_time": 0, "framework_time": 105.24242906831205, "timestamp": "2023-12-22 09:54:05.502007+00:00"},
+"16,2": {"block_size_x": 16, "block_size_y": 2, "time": 4.59481605887413, "times": [4.7124481201171875, 4.602880001068115, 4.600831985473633, 4.592639923095703, 4.593664169311523, 4.591616153717041, 4.591616153717041, 4.597760200500488, 4.589568138122559, 4.590591907501221, 4.590591907501221, 4.591616153717041, 4.589568138122559, 4.589568138122559, 4.591616153717041, 4.589568138122559, 4.588543891906738, 4.589568138122559, 4.588543891906738, 4.588543891906738, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.589568138122559, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.587520122528076], "compile_time": 855.0697029568255, "verification_time": 0, "benchmark_time": 149.2570990230888, "GFLOP/s": 1643.101073745685, "strategy_time": 0, "framework_time": 2.057977020740509, "timestamp": "2023-12-22 09:54:06.508453+00:00"}
+}
+}
diff --git a/test/test_cache_files/small_cache_one_entry.json b/test/test_cache_files/small_cache_one_entry.json
new file mode 100644
index 000000000..dab734eac
--- /dev/null
+++ b/test/test_cache_files/small_cache_one_entry.json
@@ -0,0 +1,27 @@
+{
+    "schema_version": "1.0.0",
+    "device_name": "Testing",
+    "kernel_name": "convolution_kernel",
+    "problem_size": [
+    4096,
+    4096
+    ],
+    "tune_params_keys": [
+    "block_size_x",
+    "block_size_y"
+    ],
+    "tune_params": {
+    "block_size_x": [
+    16,
+    32
+    ],
+    "block_size_y": [
+    1,
+    2
+    ]
+    },
+    "objective": "time",
+    "cache": {
+    "32,1": {"block_size_x": 32, "block_size_y": 1, "time": 3.64153603464365, "times": [3.7416958808898926, 3.645440101623535, 3.6413440704345703, 3.659775972366333, 3.6413440704345703, 3.6423680782318115, 3.640320062637329, 3.6372480392456055, 3.6382720470428467, 3.6372480392456055, 3.6372480392456055, 3.6372480392456055, 3.634176015853882, 3.6362240314483643, 3.6382720470428467, 3.6372480392456055, 3.6372480392456055, 3.6382720470428467, 3.6372480392456055, 3.6362240314483643, 3.6372480392456055, 3.6382720470428467, 3.6362240314483643, 3.6362240314483643, 3.6372480392456055, 3.634176015853882, 3.6372480392456055, 3.6372480392456055, 3.6362240314483643, 3.635200023651123, 3.635200023651123, 3.634176015853882], "compile_time": 842.062097042799, "verification_time": 0, "benchmark_time": 117.95627581886947, "GFLOP/s": 2073.231495768734, "strategy_time": 0, "framework_time": 1.9514283630996943, "timestamp": "2023-12-22 09:54:07.470476+00:00"}
+    }
+    }
\ No newline at end of file
diff --git a/test/test_cache_files/small_cache_three_entries.json b/test/test_cache_files/small_cache_three_entries.json
new file mode 100644
index 000000000..27b3fe29d
--- /dev/null
+++ b/test/test_cache_files/small_cache_three_entries.json
@@ -0,0 +1,29 @@
+{
+"schema_version": "1.0.0",
+"device_name": "Testing",
+"kernel_name": "convolution_kernel",
+"problem_size": [
+4096,
+4096
+],
+"tune_params_keys": [
+"block_size_x",
+"block_size_y"
+],
+"tune_params": {
+"block_size_x": [
+16,
+32
+],
+"block_size_y": [
+1,
+2
+]
+},
+"objective": "time",
+"cache": {
+"16,1": {"block_size_x": 16, "block_size_y": 1, "time": 3.8753279224038124, "times": [3.976191997528076, 3.8789119720458984, 3.872767925262451, 3.872767925262451, 3.8737919330596924, 3.8737919330596924, 3.872767925262451, 3.87174391746521, 3.872767925262451, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.872767925262451, 3.87174391746521, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.8696959018707275, 3.872767925262451, 3.8707199096679688, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.872767925262451, 3.872767925262451, 3.8707199096679688, 3.872767925262451, 3.8707199096679688], "compile_time": 918.5990339610726, "verification_time": 0, "benchmark_time": 126.3829180970788, "GFLOP/s": 1948.1569950129526, "strategy_time": 0, "framework_time": 105.24242906831205, "timestamp": "2023-12-22 09:54:05.502007+00:00"},
+"16,2": {"block_size_x": 16, "block_size_y": 2, "time": 4.59481605887413, "times": [4.7124481201171875, 4.602880001068115, 4.600831985473633, 4.592639923095703, 4.593664169311523, 4.591616153717041, 4.591616153717041, 4.597760200500488, 4.589568138122559, 4.590591907501221, 4.590591907501221, 4.591616153717041, 4.589568138122559, 4.589568138122559, 4.591616153717041, 4.589568138122559, 4.588543891906738, 4.589568138122559, 4.588543891906738, 4.588543891906738, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.589568138122559, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.587520122528076], "compile_time": 855.0697029568255, "verification_time": 0, "benchmark_time": 149.2570990230888, "GFLOP/s": 1643.101073745685, "strategy_time": 0, "framework_time": 2.057977020740509, "timestamp": "2023-12-22 09:54:06.508453+00:00"},
+"32,1": {"block_size_x": 32, "block_size_y": 1, "time": 3.64153603464365, "times": [3.7416958808898926, 3.645440101623535, 3.6413440704345703, 3.659775972366333, 3.6413440704345703, 3.6423680782318115, 3.640320062637329, 3.6372480392456055, 3.6382720470428467, 3.6372480392456055, 3.6372480392456055, 3.6372480392456055, 3.634176015853882, 3.6362240314483643, 3.6382720470428467, 3.6372480392456055, 3.6372480392456055, 3.6382720470428467, 3.6372480392456055, 3.6362240314483643, 3.6372480392456055, 3.6382720470428467, 3.6362240314483643, 3.6362240314483643, 3.6372480392456055, 3.634176015853882, 3.6372480392456055, 3.6372480392456055, 3.6362240314483643, 3.635200023651123, 3.635200023651123, 3.634176015853882], "compile_time": 842.062097042799, "verification_time": 0, "benchmark_time": 117.95627581886947, "GFLOP/s": 2073.231495768734, "strategy_time": 0, "framework_time": 1.9514283630996943, "timestamp": "2023-12-22 09:54:07.470476+00:00"}
+}
+}
\ No newline at end of file
diff --git a/test/test_cache_files/small_cache_unversioned.json b/test/test_cache_files/small_cache_unversioned.json
new file mode 100644
index 000000000..021ae56ed
--- /dev/null
+++ b/test/test_cache_files/small_cache_unversioned.json
@@ -0,0 +1,27 @@
+{
+"device_name": "Testing",
+"kernel_name": "convolution_kernel",
+"problem_size": [
+4096,
+4096
+],
+"tune_params_keys": [
+"block_size_x",
+"block_size_y"
+],
+"tune_params": {
+"block_size_x": [
+16,
+32
+],
+"block_size_y": [
+1,
+2
+]
+},
+"objective": "time",
+"cache": {
+"16,1": {"block_size_x": 16, "block_size_y": 1, "time": 3.8753279224038124, "times": [3.976191997528076, 3.8789119720458984, 3.872767925262451, 3.872767925262451, 3.8737919330596924, 3.8737919330596924, 3.872767925262451, 3.87174391746521, 3.872767925262451, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.872767925262451, 3.87174391746521, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.8696959018707275, 3.872767925262451, 3.8707199096679688, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.872767925262451, 3.872767925262451, 3.8707199096679688, 3.872767925262451, 3.8707199096679688], "compile_time": 918.5990339610726, "verification_time": 0, "benchmark_time": 126.3829180970788, "GFLOP/s": 1948.1569950129526, "strategy_time": 0, "framework_time": 105.24242906831205, "timestamp": "2023-12-22 09:54:05.502007+00:00"},
+"16,2": {"block_size_x": 16, "block_size_y": 2, "time": 4.59481605887413, "times": [4.7124481201171875, 4.602880001068115, 4.600831985473633, 4.592639923095703, 4.593664169311523, 4.591616153717041, 4.591616153717041, 4.597760200500488, 4.589568138122559, 4.590591907501221, 4.590591907501221, 4.591616153717041, 4.589568138122559, 4.589568138122559, 4.591616153717041, 4.589568138122559, 4.588543891906738, 4.589568138122559, 4.588543891906738, 4.588543891906738, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.589568138122559, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.587520122528076], "compile_time": 855.0697029568255, "verification_time": 0, "benchmark_time": 149.2570990230888, "GFLOP/s": 1643.101073745685, "strategy_time": 0, "framework_time": 2.057977020740509, "timestamp": "2023-12-22 09:54:06.508453+00:00"}
+}
+}
diff --git a/test/test_cachefile_class.py b/test/test_cachefile_class.py
new file mode 100644
index 000000000..881a4e635
--- /dev/null
+++ b/test/test_cachefile_class.py
@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import os
+import pytest
+import shutil
+import json
+import semver
+from pathlib import Path
+from datetime import datetime
+from types import SimpleNamespace
+from typing import cast
+
+import kernel_tuner.util as util
+from kernel_tuner.cache.cache import Cache, write_cache_file
+from kernel_tuner.cache.versions import LATEST_VERSION
+
+from jsonschema.exceptions import ValidationError
+
+TEST_DIR = Path(__file__).parent
+TEST_CACHE_DIR = TEST_DIR / "test_cache_files"
+
+class TestCache:
+    @pytest.fixture
+    def cache_path(self, tmp_path):
+        return tmp_path / "cache.json"
+
+    @pytest.fixture
+    def header(self):
+        return SimpleNamespace(
+            device_name="Test device",
+            kernel_name="Test kernel",
+            problem_size=[256, 256],
+            tune_params_keys=["a", "b", "c"],
+            tune_params={"a": [0, 1], "b": [0, 1], "c": [0, 1]},
+            objective="time",
+        )
+
+    @pytest.fixture(scope="class")
+    def now(self):
+        return datetime.now()
+
+    @pytest.fixture
+    def cache_lines(self, now):
+        LINE_JSON_TEMPLATE = {
+            "time": 0.0,
+            "times": [1.0],
+            "compile_time": 2.0,
+            "verification_time": 3,
+            "benchmark_time": 4.0,
+            "strategy_time": 6,
+            "framework_time": 7.0,
+            "timestamp": str(now),
+        }
+
+        def param_obj(a, b, c):
+            return {"a": a, "b": b, "c": c}
+
+        return {
+            "0,0,0": {**param_obj(0, 0, 0), **LINE_JSON_TEMPLATE},
+            "0,0,1": {**param_obj(0, 0, 1), **LINE_JSON_TEMPLATE},
+            "0,1,0": {**param_obj(0, 1, 0), **LINE_JSON_TEMPLATE},
+            "1,1,0": {**param_obj(1, 1, 0), **LINE_JSON_TEMPLATE},
+        }
+
+    @pytest.fixture
+    def cache_json(self, header, cache_lines):
+        return {"schema_version": str(LATEST_VERSION), **vars(header), "cache": cache_lines}
+
+    @pytest.fixture
+    def assert_create__raises_ValueError(self, cache_path, header):
+        yield
+        with pytest.raises(ValueError):
+            Cache.create(cache_path, **vars(header))
+
+    @pytest.fixture
+    def assert_create__raises_ValidationError(self, cache_path, header):
+        yield
+        with pytest.raises(ValidationError):
+            Cache.create(cache_path, **vars(header))
+
+    def test_create(self, cache_path, header):
+        Cache.create(cache_path, **vars(header))
+        with open(cache_path) as file:
+            data = json.load(file)
+        assert "schema_version" in data
+        assert {**data, "schema_version": "*"} == {"schema_version": "*", **vars(header), "cache": {}}
+
+    def test_create__returns_object(self, cache_path, header):
+        cache = Cache.create(cache_path, **vars(header))
+        assert os.path.normpath(cache.filepath) == os.path.normpath(cache_path)
+
+    def test_create__invalid_device_name(self, header, assert_create__raises_ValidationError):
+        header.device_name = 3
+
+    def test_create__invalid_kernel_name(self, header, assert_create__raises_ValidationError):
+        header.kernel_name = True
+
+    def test_create__invalid_tune_params__types(self, header, assert_create__raises_ValueError):
+        header.tune_params_keys = [1, True, False]
+        header.tune_params = {1: [1], True: [True], False: [False]}
+
+    def test_create__invalid_tune_params__mismatch(self, header, assert_create__raises_ValueError):
+        header.tune_params_keys = ["a", "b"]
+
+    @pytest.mark.parametrize(
+        "key",
+        [
+            "time",
+            "compile_time",
+            "verification_time",
+            "benchmark_time",
+            "strategy_time",
+            "framework_time",
+            "timestamp",
+            "times",
+        ],
+    )
+    def test_create__invalid_tune_params__reserved_keys(self, header, key, assert_create__raises_ValueError):
+        header.tune_params_keys.append(key)
+        header.tune_params[key] = [1, 2]
+
+    def test_create__invalid_objective(self, header, assert_create__raises_ValidationError):
+        header.objective = 3.141592
+
+    @pytest.fixture
+    def cache_file(self, cache_path, cache_json):
+        write_cache_file(cache_json, cache_path)
+        yield cache_path
+
+    @pytest.fixture
+    def cache(self, cache_file):
+        return Cache.read(cache_file)
+
+    @pytest.fixture
+    def cache_line_read(self, cache) -> Cache.Line:
+        return cache.lines.get_from_params(a=0, b=0, c=0)
+
+    def test_open(self, cache, header, cache_lines):
+        pass
+
+    def test_version(self, cache):
+        assert isinstance(cache.version, semver.Version)
+
+    def test_header(self, cache, header):
+        assert cache.device_name == header.device_name
+        assert cache.kernel_name == header.kernel_name
+        assert list(cache.tune_params_keys) == header.tune_params_keys
+        assert list(cache.tune_params["a"]) == header.tune_params["a"]
+        assert list(cache.problem_size) == header.problem_size
+        assert cache.objective == header.objective
+
+    def test_lines_get(self, cache, cache_lines):
+        assert cache.lines.get_from_params(a=0, b=0, c=0) == cache_lines["0,0,0"]
+
+    def test_lines_get__default(self, cache):
+        assert cache.lines.get("1,0,0", "Hi!") == "Hi!"
+        assert cache.lines.get_from_params(a=1, b=0, c=0, default="DEF") == "DEF"
+
+    def test_lines_get__multiple(self, cache):
+        assert len(cache.lines.get_from_params(b=1, c=1)) == 0
+        assert len(cache.lines.get_from_params(b=2)) == 0
+        assert len(cache.lines.get_from_params(a=0)) == 3
+
+    def test_lines_get__no_KeyError(self, cache):
+        cache.lines.get("gibberish")
+
+    def test_lines_get__with_non_existing_param_key(self, cache):
+        with pytest.raises(ValueError):
+            cache.lines.get_from_params(d=0)
+
+    def test_line_attributes(self, cache_line_read, now):
+        assert cache_line_read.time == 0
+        assert cache_line_read.times == [1]
+        assert cache_line_read.compile_time == 2
+        assert cache_line_read.verification_time == 3
+        assert cache_line_read.benchmark_time == 4
+        assert cache_line_read.strategy_time == 6
+        assert cache_line_read.framework_time == 7
+        assert cache_line_read.timestamp == str(now)
+
+    def test_line_dict(self, cache_line_read, cache_json, now):
+        assert dict(cache_line_read) == {
+            "a": 0,
+            "b": 0,
+            "c": 0,
+            "time": 0,
+            "times": [1],
+            "compile_time": 2,
+            "verification_time": 3,
+            "benchmark_time": 4,
+            "strategy_time": 6,
+            "framework_time": 7,
+            "timestamp": str(now),
+        }
+
+    def test_line_dict__json_and_non_json(self, cache: Cache, now):
+        cache.lines.append(
+            time=util.RuntimeFailedConfig(),
+            compile_time=1.0,
+            verification_time=2,
+            benchmark_time=3.0,
+            strategy_time=4,
+            framework_time=5.0,
+            timestamp=str(now),
+            times=[6.0],
+            a=1,
+            b=1,
+            c=1,
+        )
+        line = cache.lines.get_from_params(a=1, b=1, c=1)
+
+        print(line)
+        print(list(line.keys()))
+
+        assert line["time"] == util.RuntimeFailedConfig.__name__
+        assert line["timestamp"] == str(now)
+
+    @pytest.fixture
+    def cache_line(self):
+        return SimpleNamespace(
+            time=99.9,
+            compile_time=1.0,
+            verification_time=2,
+            benchmark_time=3.0,
+            strategy_time=4,
+            framework_time=5.0,
+            timestamp=str(datetime.now()),
+        )
+
+    @pytest.fixture
+    def full_cache_line(self, cache_line):
+        cache_line.a = 1
+        cache_line.b = 1
+        cache_line.c = 1
+        return cache_line
+
+    @pytest.fixture
+    def assert_can_append_line(self, cache, cache_line):
+        yield
+        prev_len = len(cache.lines)
+        cache.lines.append(**vars(cache_line))
+        assert len(cache.lines) == prev_len + 1
+        cache = Cache.read(cache.filepath)
+        assert len(cache.lines) == prev_len + 1
+
+    @pytest.fixture
+    def assert_append_line__raises_ValueError(self, cache, cache_line):
+        yield
+        with pytest.raises(ValueError):
+            cache.lines.append(**vars(cache_line))
+
+    @pytest.fixture
+    def assert_append_line__raises_ValidationError(self, cache, cache_line):
+        yield
+        with pytest.raises(ValidationError):
+            cache.lines.append(**vars(cache_line))
+
+    def test_line_append(self, full_cache_line, assert_can_append_line):
+        pass
+
+    def test_line_append__with_ErrorConfig(self, full_cache_line, assert_can_append_line):
+        full_cache_line.time = util.InvalidConfig()
+
+    def test_line_append__with_partial_params(self, cache_line, assert_append_line__raises_ValueError):
+        cache_line.a = 1
+
+    def test_line_append__with_invalid_tune_params(self, full_cache_line, assert_append_line__raises_ValueError):
+        full_cache_line.a = 2
+
+    def test_line_append__with_invalid_time(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.time = "abc"
+
+    def test_line_append__with_invalid_compile_time(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.compile_time = True
+
+    def test_line_append__with_invalid_verificat_time(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.verification_time = None
+
+    def test_line_append__with_invalid_benchmark_time(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.benchmark_time = []
+
+    def test_line_append__with_invalid_strategy_time(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.strategy_time = {}
+
+    def test_line_append__with_invalid_framework_time(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.framework_time = False
+
+    def test_line_append__with_invalid_timestamp(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.timestamp = 88
+
+    def test_line_append__with_invalid_times(self, full_cache_line, assert_append_line__raises_ValidationError):
+        full_cache_line.times = ["Hello"]
+
+    def test_read(self, cache_file):
+        Cache.read(cache_file)
+
+    @pytest.fixture
+    def cache_backup_file(self, cache_file):
+        backup_file = cache_file.with_suffix(".bak")
+        shutil.copy(cache_file, backup_file)
+        return backup_file
+
+    @pytest.fixture
+    def assert_cache_unchanged(self, cache_file, cache_backup_file):
+        yield
+        with open(cache_file) as cache, open(cache_backup_file) as backup:
+            assert cache.read() == backup.read()
+
+    def test_read__cannot_modify(self, cache_file, full_cache_line, assert_cache_unchanged):
+        cache = Cache.read(cache_file, read_only=True)
+        with pytest.raises(ValueError):
+            cache.lines.append(**vars(full_cache_line))
diff --git a/test/test_cachefile_encoder.py b/test/test_cachefile_encoder.py
new file mode 100644
index 000000000..997458453
--- /dev/null
+++ b/test/test_cachefile_encoder.py
@@ -0,0 +1,37 @@
+import json
+import numpy as np
+
+from kernel_tuner.cache.cache import CacheEncoder
+from kernel_tuner.util import ErrorConfig, InvalidConfig, CompilationFailedConfig, RuntimeFailedConfig
+
+
+def dumps(data):
+    return json.dumps(data, cls=CacheEncoder, indent="")
+
+
+class TestCacheJSONEncoder:
+
+    def test_encode_cache_last(self):
+        test_obj = {"b": 2, "cache": {}, "d": 4}
+        dump_str = dumps(test_obj)
+        expected = '{\n"b": 2,\n"d": 4,\n"cache": {}\n}'
+        print("received:")
+        print(dump_str)
+        print("expected:")
+        print(expected)
+        assert dump_str == expected
+
+    def test_encode_error_config(self):
+        assert dumps(ErrorConfig()) == '"ErrorConfig"'
+        assert dumps(InvalidConfig()) == '"InvalidConfig"'
+        assert dumps(CompilationFailedConfig()) == '"CompilationFailedConfig"'
+        assert dumps(RuntimeFailedConfig()) == '"RuntimeFailedConfig"'
+
+    def test_encode_np_int(self):
+        assert dumps(np.int16(1234)) == "1234"
+
+    def test_encode_np_float(self):
+        assert dumps(np.float16(1.0)) == "1.0"
+
+    def test_encode_np_array(self):
+        assert dumps(np.array([3, 1, 4, 1, 5])) == "[\n3,\n1,\n4,\n1,\n5\n]"
diff --git a/test/test_cachefile_read_write.py b/test/test_cachefile_read_write.py
new file mode 100644
index 000000000..b1bbfadcc
--- /dev/null
+++ b/test/test_cachefile_read_write.py
@@ -0,0 +1,104 @@
+import re
+
+import pytest
+import shutil
+from copy import deepcopy
+from pathlib import Path
+
+from kernel_tuner.cache.file import (
+    CachedLinePosition,
+    append_cache_line
+)
+from kernel_tuner.cache.cache import read_cache_file, write_cache_file, _encode_cache_line, InvalidCacheError
+
+TEST_DIR = Path(__file__).parent
+TEST_CACHE_DIR = TEST_DIR / "test_cache_files"
+SMALL_CACHE_PATH = TEST_CACHE_DIR / "small_cache.json"
+LARGE_CACHE_PATH = TEST_CACHE_DIR / "large_cache.json"
+
+
+@pytest.fixture
+def output_path(tmp_path):
+    return tmp_path / "output.json"
+
+
+@pytest.fixture(params=[SMALL_CACHE_PATH, LARGE_CACHE_PATH], ids=["small", "large"])
+def cache_path(request):
+    return request.param
+
+
+def test_read_cache(cache_path, output_path):
+    shutil.copy(cache_path, output_path)
+
+    # Read device name of the given file
+    file_content = read_cache_file(output_path)
+    device_name = file_content.get("device_name")
+
+    # Check if the expected value of device name is in the file
+    assert isinstance(device_name, str)
+
+    # Check if the file has remained unchanged
+    with open(output_path) as output, open(cache_path) as expected:
+        assert output.read().rstrip() == expected.read().rstrip()
+
+
+def test_read_cache__which_is_unparsable(output_path):
+    with open(output_path, "w") as file:
+        file.write("INVALID")
+
+    with pytest.raises(InvalidCacheError):
+        read_cache_file(output_path)
+
+
+def test_write_cache(cache_path, output_path):
+    sample_cache = read_cache_file(cache_path)
+
+    write_cache_file(sample_cache, output_path)
+    regex = re.compile(r'[\s]+')
+
+    # do a whitespace insensitive compare
+    with open(output_path, "r") as output, open(cache_path, "r") as input:
+        assert regex.sub("", output.read().rstrip()) == regex.sub("", input.read().rstrip())
+
+
+def test_append_cache_line(cache_path, output_path):
+    sample_cache = read_cache_file(cache_path)
+
+    smaller_cache = deepcopy(sample_cache)
+    key = next(iter(smaller_cache["cache"].keys()))
+    line = smaller_cache["cache"].pop(key)
+
+    write_cache_file(smaller_cache, output_path)
+    line_str = _encode_cache_line(key, line)
+    append_cache_line(line_str, output_path)
+
+    assert read_cache_file(output_path) == sample_cache
+
+
+def test_append_cache_line__with_position(cache_path, output_path):
+    sample_cache = read_cache_file(cache_path)
+
+    empty_cache = deepcopy(sample_cache)
+    cache_lines = deepcopy(empty_cache["cache"])
+    empty_cache["cache"].clear()
+    write_cache_file(empty_cache, output_path)
+
+    pos = CachedLinePosition()
+    for key, line in cache_lines.items():
+        pos = append_cache_line(_encode_cache_line(key, line), output_path, pos)
+
+    assert read_cache_file(output_path) == sample_cache
+
+
+def test_append_cache_line__to_empty_cache(cache_path, output_path):
+    sample_cache = read_cache_file(cache_path)
+
+    empty_cache = deepcopy(sample_cache)
+    cache_lines = deepcopy(empty_cache["cache"])
+    empty_cache["cache"].clear()
+
+    write_cache_file(empty_cache, output_path)
+    for key, line in cache_lines.items():
+        append_cache_line(_encode_cache_line(key, line), output_path)
+
+    assert read_cache_file(output_path) == sample_cache
diff --git a/test/test_cachefile_schema.py b/test/test_cachefile_schema.py
new file mode 100644
index 000000000..7c05cc244
--- /dev/null
+++ b/test/test_cachefile_schema.py
@@ -0,0 +1,234 @@
+import json
+from copy import deepcopy
+from pathlib import Path
+
+import jsonschema
+import pytest
+
+import kernel_tuner
+from kernel_tuner.cache.json import CacheFileJSON, CacheLineJSON
+from kernel_tuner.cache.cache import Cache
+from kernel_tuner.cache.cache import validate_json
+import jsonschema
+import pytest
+import kernel_tuner
+
+
+KERNEL_TUNER_PATH = Path(kernel_tuner.__file__).parent
+SCHEMA_PATH = KERNEL_TUNER_PATH / "schema/cache/1.0.0/schema.json"
+
+TEST_PATH = Path(__file__).parent
+TEST_CACHE_PATH = TEST_PATH / "test_cache_files"
+SMALL_CACHE_PATH = TEST_CACHE_PATH / "small_cache.json"
+LARGE_CACHE_PATH = TEST_CACHE_PATH / "large_cache.json"
+
+
+with open(SMALL_CACHE_PATH) as f:
+    SMALL_CACHE = json.load(f)
+with open(LARGE_CACHE_PATH) as f:
+    LARGE_CACHE = json.load(f)
+
+
+@pytest.fixture()
+def cache() -> CacheFileJSON:
+    return deepcopy(SMALL_CACHE)
+
+
+@pytest.fixture()
+def large(cache):
+    cache.clear()
+    cache.update(deepcopy(LARGE_CACHE))
+
+
+@pytest.fixture(params=[0, -1], ids=["first_cache_line", "last_cache_line"])
+def cache_line(cache, request) -> CacheLineJSON:
+    """Fixture for obtaining a reference to an arbitrary cache line.
+
+    Note: When using fixture large, don't put `cache_line` before
+    fixture `large` in the parameter list of a test or fixture
+    """
+    index = request.param
+    cache_keys = list(cache["cache"].keys())
+    cache_key = cache_keys[index]
+    return cache["cache"][cache_key]
+
+
+@pytest.fixture()
+def is_valid(cache):
+    yield  # let the test apply some modifications
+
+    validate_json(cache)  # assert the cache is valid
+
+
+@pytest.fixture()
+def is_invalid(cache):
+    yield  # let the test apply some modifications
+    with pytest.raises(jsonschema.exceptions.ValidationError):
+        validate_json(cache)  # assert the cache is invalid
+
+
+@pytest.fixture()
+def invalid_timestamp_cache() -> dict:
+    return {
+        "schema_version": "1.0.0",
+        "device_name": "Testing",
+        "kernel_name": "convolution_kernel",
+        "problem_size": [4096, 4096],
+        "tune_params_keys": ["block_size_x"],
+        "tune_params": {"block_size_x": [16, 32]},
+        "objective": "time",
+        "cache": {
+            "16,1,1,1,0,0,0,1,15,15": {
+                "block_size_x": 16,
+                "time": 3.875,
+                "compile_time": 918.6,
+                "verification_time": 0,
+                "benchmark_time": 126.3,
+                "strategy_time": 0,
+                "framework_time": 105.2,
+                "timestamp": "2023",
+            }
+        },
+    }
+
+
+@pytest.fixture()
+def invalid_schemaversion_cache() -> dict:
+    return {
+        "schema_version": "20.9.8",
+        "device_name": "Testing",
+        "kernel_name": "convolution_kernel",
+        "problem_size": [4096, 4096],
+        "tune_params_keys": ["block_size_x"],
+        "tune_params": {"block_size_x": [16, 32]},
+        "objective": "time",
+        "cache": {
+            "16,1,1,1,0,0,0,1,15,15": {
+                "block_size_x": 16,
+                "time": 3.875,
+                "compile_time": 918.6,
+                "verification_time": 0,
+                "benchmark_time": 126.3,
+                "strategy_time": 0,
+                "framework_time": 105.2,
+                "timestamp": "2023-12-22T10:33:29.006875+00:00",
+            }
+        },
+    }
+
+
+class TestCacheFileSchema:
+    def test_small_cache_is_valid(self, cache, is_valid):
+        pass
+
+    def test_large_cache_is_valid(self, large, cache, is_valid):
+        pass
+
+    def test_schema_version_is_valid(self, cache, is_invalid):
+        cache["schema_version"] = "0.1.0"
+
+    @pytest.mark.parametrize(
+        "key",
+        [
+            "schema_version",
+            "device_name",
+            "kernel_name",
+            "problem_size",
+            "tune_params_keys",
+            "tune_params",
+            "objective",
+            "cache",
+        ],
+    )
+    def test_required_keys__in_root(self, cache, is_invalid, key):
+        del cache[key]
+
+    @pytest.mark.parametrize(
+        "key,value",
+        [
+            ("schema_version", 1234),
+            ("device_name", 2312),
+            ("kernel_name", True),
+            ("problem_size", 2.5),
+            ("tune_params_keys", {}),
+            ("tune_params", []),
+            ("objective", 4.5),
+            ("cache", []),
+        ],
+    )
+    def test_property_types_invalid__in_root(self, cache, is_invalid, key, value):
+        cache[key] = value
+
+    @pytest.mark.parametrize(
+        "key,value",
+        [
+            ("schema_version", "1.0.0"),
+            ("device_name", "test_device"),
+            ("kernel_name", "test_kernel"),
+            ("problem_size", [100, 100]),
+            ("tune_params_keys", ["block_size_x"]),
+            ("tune_params", { "block_size_x": [128, 256, 512, 1024] }),
+            ("objective", "time"),
+            ("cache", {})
+        ],
+    )
+    def test_property_types_valid__in_root(self, cache, is_valid, key, value):
+        cache[key] = value
+
+    @pytest.mark.parametrize(
+        "key,value",
+        {
+            ("my_very_uncommon_key", 1),
+            ("fewajfewaijfewa", 2),
+        },
+    )
+    def test_additional_props_allowed__in_root(self, cache, is_valid, key, value):
+        cache[key] = value
+
+    @pytest.mark.parametrize(
+        "key",
+        [
+            "time",
+            "compile_time",
+            "verification_time",
+            "benchmark_time",
+            "strategy_time",
+            "framework_time",
+            "timestamp",
+        ],
+    )
+    def test_required_keys__in_cache_line(self, cache_line, is_invalid, key):
+        del cache_line[key]
+
+    @pytest.mark.parametrize(
+        "key,value",
+        [
+            ("time", True),
+            ("times", {}),
+            ("times", ["x"]),
+            ("compile_time", None),
+            ("verification_time", True),
+            ("benchmark_time", "Invalid"),
+            ("strategy_time", "123"),
+            ("framework_time", "15"),
+            ("timestamp", 42),
+        ],
+    )
+    def test_property_types__in_cache_line(self, cache_line, is_invalid, key, value):
+        cache_line[key] = value
+
+    @pytest.mark.parametrize(
+        "key,value",
+        [
+            ("anyParameter", 45),
+            ("xyz", [2, 3, 4]),
+        ],
+    )
+    def test_additional_props_allowed__in_cache_line(self, cache_line, is_valid, key, value):
+        cache_line[key] = value
+
+    def test_invalid_timestamp_cache(self, cache, invalid_timestamp_cache, is_invalid):
+        cache.update(invalid_timestamp_cache)
+
+    def test_invalid_schema_version(self, cache, invalid_schemaversion_cache, is_invalid):
+        cache.update(invalid_schemaversion_cache)
diff --git a/test/test_convert_cache.py b/test/test_convert_cache.py
new file mode 100644
index 000000000..f31137c3e
--- /dev/null
+++ b/test/test_convert_cache.py
@@ -0,0 +1,178 @@
+import json
+from pathlib import Path
+from shutil import copyfile
+
+import jsonschema
+import pytest
+
+from kernel_tuner.cache.cache import convert_cache_file
+from kernel_tuner.cache.convert import convert_cache_to_t4, default_convert, unversioned_convert
+from kernel_tuner.cache.paths import CACHE_SCHEMAS_DIR, SCHEMA_DIR
+from kernel_tuner.cache.versions import VERSIONS
+
+TEST_PATH = Path(__file__).parent
+TEST_CONVERT_PATH = TEST_PATH / "test_convert_files"
+
+# Mock schema files
+MOCK_CACHE_FILE = TEST_CONVERT_PATH / "mock_cache.json"
+
+MOCK_SCHEMAS_PATH = TEST_CONVERT_PATH / "mock_schemas"
+MOCK_SCHEMA_OLD = MOCK_SCHEMAS_PATH / "1.0.0/schema.json"
+MOCK_SCHEMA_NEW = MOCK_SCHEMAS_PATH / "1.2.0/schema.json"
+UPGRADED_SCHEMA = MOCK_SCHEMAS_PATH / "1.1.0/schema.json"
+
+# Actual schema files
+REAL_CACHE_FILE = TEST_CONVERT_PATH / "real_cache.json"
+
+SCHEMA_OLD = CACHE_SCHEMAS_DIR / str(VERSIONS[0]) / "schema.json"
+SCHEMA_NEW = CACHE_SCHEMAS_DIR / str(VERSIONS[-1]) / "schema.json"
+
+# Test files
+NO_VERSION_FIELD = TEST_CONVERT_PATH / "no_version_field.json"
+TOO_HIGH_VERSION = TEST_CONVERT_PATH / "too_high_version.json"
+NOT_REAL_VERSION = TEST_CONVERT_PATH / "not_real_version.json"
+
+# T4 schema files
+T4_SCHEMA = SCHEMA_DIR / "T4/1.0.0/results-schema.json"
+
+# T4 Test files
+T4_CACHE = TEST_CONVERT_PATH / "t4_cache.json"
+T4_CACHE_INVALID = TEST_CONVERT_PATH / "t4_cache_invalids.json"
+T4_TARGET = TEST_CONVERT_PATH / "t4_target.json"
+
+
+class TestConvertCache:
+    # Test using mock schema/cache files and conversion functions
+    def test_conversion_system(self, tmp_path):
+        TEST_COPY = tmp_path / "temp_cache.json"
+        copyfile(MOCK_CACHE_FILE, TEST_COPY)
+
+        with open(TEST_COPY) as c, open(MOCK_SCHEMA_OLD) as s:
+            mock_cache = json.load(c)
+            mock_schema = json.load(s)
+            jsonschema.validate(mock_cache, mock_schema)
+
+        convert_cache_file(TEST_COPY, self._CONVERT_FUNCTIONS, self._VERSIONS)
+
+        with open(TEST_COPY) as c, open(MOCK_SCHEMA_NEW) as s:
+            mock_cache = json.load(c)
+            mock_schema = json.load(s)
+            jsonschema.validate(mock_cache, mock_schema)
+
+    # Test using implemented schema/cache files and conversion functions
+    def test_convert_real(self, tmp_path):
+        TEST_COPY = tmp_path / "temp_cache.json"
+        copyfile(REAL_CACHE_FILE, TEST_COPY)
+
+        with open(TEST_COPY) as c, open(SCHEMA_OLD) as s:
+            real_cache = json.load(c)
+            real_schema = json.load(s)
+            jsonschema.validate(real_cache, real_schema)
+
+        convert_cache_file(TEST_COPY)
+
+        with open(TEST_COPY) as c, open(SCHEMA_NEW) as s:
+            real_cache = json.load(c)
+            real_schema = json.load(s)
+            jsonschema.validate(real_cache, real_schema)
+
+    def test_no_version_field(self, tmp_path):
+        TEST_COPY = tmp_path / "temp_cache.json"
+        copyfile(NO_VERSION_FIELD, TEST_COPY)
+
+        with open(TEST_COPY) as c:
+            cache = json.load(c)
+
+        cache = unversioned_convert(cache, MOCK_SCHEMAS_PATH)
+
+        with open(MOCK_SCHEMA_OLD) as s:
+            schema = json.load(s)
+            jsonschema.validate(cache, schema)
+
+    def test_too_high_version(self, tmp_path):
+        TEST_COPY = tmp_path / "temp_cache.json"
+        copyfile(TOO_HIGH_VERSION, TEST_COPY)
+
+        with pytest.raises(ValueError):
+            convert_cache_file(TEST_COPY, self._CONVERT_FUNCTIONS, self._VERSIONS)
+
+    def test_not_real_version(self, tmp_path):
+        TEST_COPY = tmp_path / "temp_cache.json"
+        copyfile(NOT_REAL_VERSION, TEST_COPY)
+
+        with pytest.raises(ValueError):
+            convert_cache_file(TEST_COPY, self._CONVERT_FUNCTIONS, self._VERSIONS)
+
+    def test_default_convert(self):
+        with open(MOCK_CACHE_FILE) as c:
+            cache = json.load(c)
+
+        cache = default_convert(cache, "1.0.0", self._VERSIONS, MOCK_SCHEMAS_PATH)
+
+        with open(UPGRADED_SCHEMA) as s:
+            upgraded_schema = json.load(s)
+            jsonschema.validate(cache, upgraded_schema)
+
+    def test_convert_to_t4(self):
+        with open(T4_CACHE) as cache_file, open(T4_TARGET) as t4_target_file:
+            cache = json.load(cache_file)
+            t4_target = json.load(t4_target_file)
+
+        t4 = convert_cache_to_t4(cache)
+
+        if t4 != t4_target:
+            raise ValueError("Converted T4 does not match target T4")
+
+    def test_convert_to_t4_with_invalids(self):
+        with open(T4_CACHE_INVALID) as cache_file:
+            cache = json.load(cache_file)
+
+        t4 = convert_cache_to_t4(cache)
+
+        print(t4)
+
+        # T4 format always contains an 'results' array for individual measurements
+        assert len(t4["results"]) == 1
+
+        # Test if first entry has properly been converted
+        assert t4["results"][0]["invalidity"] == "compile"
+        assert t4["results"][0]["correctness"] == 0
+
+    def test_convert_to_t4_is_valid(self):
+        with open(T4_CACHE) as cache_file:
+            cache = json.load(cache_file)
+
+        t4_converted_output = convert_cache_to_t4(cache)
+
+        with open(T4_SCHEMA) as t4_schema_file:
+            t4_schema = json.load(t4_schema_file)
+            jsonschema.validate(t4_converted_output, t4_schema)
+
+    # Mock convert functions
+    @staticmethod
+    def _c1_0_0_to_1_1_0(cache):
+        cache["cache"] = {}
+        cache["field2"] = dict()
+        cache["schema_version"] = "1.1.0"
+        return cache
+
+    @staticmethod
+    def _c1_1_0_to_1_1_1(cache):
+        cache["cache"] = {}
+        cache["schema_version"] = "1.1.1"
+        return cache
+
+    @staticmethod
+    def _c1_1_1_to_1_2_0(cache):
+        cache["cache"] = {}
+        cache["field1"] = dict()
+        cache["schema_version"] = "1.2.0"
+        return cache
+
+    _CONVERT_FUNCTIONS = {
+        "1.0.0": _c1_0_0_to_1_1_0.__func__,
+        "1.1.0": _c1_1_0_to_1_1_1.__func__,
+        "1.1.1": _c1_1_1_to_1_2_0.__func__,
+    }
+
+    _VERSIONS = ["1.0.0", "1.1.0", "1.1.1", "1.2.0"]
diff --git a/test/test_convert_files/mock_cache.json b/test/test_convert_files/mock_cache.json
new file mode 100644
index 000000000..bd736c5c3
--- /dev/null
+++ b/test/test_convert_files/mock_cache.json
@@ -0,0 +1,4 @@
+{
+    "schema_version": "1.0.0",
+    "field1": "Not a default value"
+}
\ No newline at end of file
diff --git a/test/test_convert_files/mock_schemas/1.0.0/schema.json b/test/test_convert_files/mock_schemas/1.0.0/schema.json
new file mode 100644
index 000000000..e04d2dc86
--- /dev/null
+++ b/test/test_convert_files/mock_schemas/1.0.0/schema.json
@@ -0,0 +1,14 @@
+{
+    "description": "abc",
+    "properties": {
+        "schema_version": {
+            "type": "string",
+            "description": "The version of this JSON-schema, adhering to the Semantic Versioning specification.",
+            "const": "1.0.0"
+        },
+        "field1": {
+            "type": "string",
+            "description": "a string"
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/test_convert_files/mock_schemas/1.1.0/schema.json b/test/test_convert_files/mock_schemas/1.1.0/schema.json
new file mode 100644
index 000000000..488399b96
--- /dev/null
+++ b/test/test_convert_files/mock_schemas/1.1.0/schema.json
@@ -0,0 +1,18 @@
+{
+    "description": "abc",
+    "properties": {
+        "schema_version": {
+            "type": "string",
+            "description": "The version of this JSON-schema, adhering to the Semantic Versioning specification.",
+            "const": "1.1.0"
+        },
+        "field1": {
+            "type": "string",
+            "description": "a string"
+        },
+        "field2": {
+            "type": "object",
+            "description": "an object"
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/test_convert_files/mock_schemas/1.1.1/schema.json b/test/test_convert_files/mock_schemas/1.1.1/schema.json
new file mode 100644
index 000000000..e5bd1631d
--- /dev/null
+++ b/test/test_convert_files/mock_schemas/1.1.1/schema.json
@@ -0,0 +1,18 @@
+{
+    "description": "Abc",
+    "properties": {
+        "schema_version": {
+            "type": "string",
+            "description": "The version of this JSON-schema, adhering to the Semantic Versioning specification.",
+            "const": "1.1.1"
+        },
+        "field1": {
+            "type": "string",
+            "description": "A string"
+        },
+        "field2": {
+            "type": "object",
+            "description": "An object"
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/test_convert_files/mock_schemas/1.2.0/schema.json b/test/test_convert_files/mock_schemas/1.2.0/schema.json
new file mode 100644
index 000000000..07ca31316
--- /dev/null
+++ b/test/test_convert_files/mock_schemas/1.2.0/schema.json
@@ -0,0 +1,18 @@
+{
+    "description": "abc",
+    "properties": {
+        "schema_version": {
+            "type": "string",
+            "description": "The version of this JSON-schema, adhering to the Semantic Versioning specification.",
+            "const": "1.2.0"
+        },
+        "field1": {
+            "type": "object",
+            "description": "now an object"
+        },
+        "field2": {
+            "type": "object",
+            "description": "an object"
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/test_convert_files/no_version_field.json b/test/test_convert_files/no_version_field.json
new file mode 100644
index 000000000..2c5d8c0fa
--- /dev/null
+++ b/test/test_convert_files/no_version_field.json
@@ -0,0 +1,4 @@
+{
+    "field1": "Not a default value",
+    "cache": {}
+}
diff --git a/test/test_convert_files/not_real_version.json b/test/test_convert_files/not_real_version.json
new file mode 100644
index 000000000..b623a013c
--- /dev/null
+++ b/test/test_convert_files/not_real_version.json
@@ -0,0 +1,4 @@
+{
+    "schema_version": "1.0.1",
+    "field1": "Not a default value"
+}
\ No newline at end of file
diff --git a/test/test_convert_files/real_cache.json b/test/test_convert_files/real_cache.json
new file mode 100644
index 000000000..9655870d6
--- /dev/null
+++ b/test/test_convert_files/real_cache.json
@@ -0,0 +1,27 @@
+{
+"schema_version": "1.0.0",
+"device_name": "Testing",
+"kernel_name": "convolution_kernel",
+"problem_size": [
+4096,
+4096
+],
+"tune_params_keys": [
+"block_size_x",
+"block_size_y"
+],
+"tune_params": {
+"block_size_x": [
+16,
+32
+],
+"block_size_y": [
+1,
+2
+]
+},
+"objective": "time",
+"cache": {
+"16,1": {"block_size_x": 16, "block_size_y": 1, "time": 3.8753279224038124, "times": [3.976191997528076, 3.8789119720458984, 3.872767925262451, 3.872767925262451, 3.8737919330596924, 3.8737919330596924, 3.872767925262451, 3.87174391746521, 3.872767925262451, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.872767925262451, 3.87174391746521, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.87174391746521, 3.8696959018707275, 3.872767925262451, 3.8707199096679688, 3.8707199096679688, 3.87174391746521, 3.8707199096679688, 3.87174391746521, 3.872767925262451, 3.872767925262451, 3.8707199096679688, 3.872767925262451, 3.8707199096679688], "compile_time": 918.5990339610726, "verification_time": 0, "benchmark_time": 126.3829180970788, "GFLOP/s": 1948.1569950129526, "strategy_time": 0, "framework_time": 105.24242906831205, "timestamp": "2023-12-22 09:54:05.502007+00:00"},
+"16,2": {"block_size_x": 16, "block_size_y": 2, "time": 4.59481605887413, "times": [4.7124481201171875, 4.602880001068115, 4.600831985473633, 4.592639923095703, 4.593664169311523, 4.591616153717041, 4.591616153717041, 4.597760200500488, 4.589568138122559, 4.590591907501221, 4.590591907501221, 4.591616153717041, 4.589568138122559, 4.589568138122559, 4.591616153717041, 4.589568138122559, 4.588543891906738, 4.589568138122559, 4.588543891906738, 4.588543891906738, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.590591907501221, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.589568138122559, 4.587520122528076, 4.589568138122559, 4.589568138122559, 4.587520122528076], "compile_time": 855.0697029568255, "verification_time": 0, "benchmark_time": 149.2570990230888, "GFLOP/s": 1643.101073745685, "strategy_time": 0, "framework_time": 2.057977020740509, "timestamp": "2023-12-22 09:54:06.508453+00:00"}
+}}
diff --git a/test/test_convert_files/t4_cache.json b/test/test_convert_files/t4_cache.json
new file mode 100644
index 000000000..6d889c5d6
--- /dev/null
+++ b/test/test_convert_files/t4_cache.json
@@ -0,0 +1,109 @@
+{
+    "schema_version": "1.0.0",
+    "device_name": "",
+    "kernel_name": "convolution_kernel",
+    "problem_size": [
+        4096,
+        4096
+    ],
+    "tune_params_keys": [
+        "block_size_x",
+        "block_size_y",
+        "tile_size_x",
+        "tile_size_y",
+        "read_only",
+        "use_padding",
+        "use_shmem",
+        "use_cmem",
+        "filter_height",
+        "filter_width"
+    ],
+    "tune_params": {
+        "block_size_x": [
+            16
+        ],
+        "block_size_y": [
+            1
+        ],
+        "tile_size_x": [
+            1
+        ],
+        "tile_size_y": [
+            1
+        ],
+        "read_only": [
+            0
+        ],
+        "use_padding": [
+            0
+        ],
+        "use_shmem": [
+            0
+        ],
+        "use_cmem": [
+            1
+        ],
+        "filter_height": [
+            15
+        ],
+        "filter_width": [
+            15
+        ]
+    },
+    "objective": "time",
+    "cache": {
+        "16,1,1,1,0,0,0,1,15,15": {
+            "block_size_x": 16,
+            "block_size_y": 1,
+            "tile_size_x": 1,
+            "tile_size_y": 1,
+            "read_only": 0,
+            "use_padding": 0,
+            "use_shmem": 0,
+            "use_cmem": 1,
+            "filter_height": 15,
+            "filter_width": 15,
+            "time": 12.262957006692886,
+            "times": [
+                12.265098571777344,
+                12.252779960632324,
+                12.25790023803711,
+                12.253418922424316,
+                12.254219055175781,
+                12.26366138458252,
+                12.251818656921387,
+                12.264618873596191,
+                12.252618789672852,
+                12.257740020751953,
+                12.259658813476562,
+                12.253725051879883,
+                12.257899284362793,
+                12.25325870513916,
+                12.25629997253418,
+                12.25309944152832,
+                12.258379936218262,
+                12.264481544494629,
+                12.258378982543945,
+                12.258858680725098,
+                12.262378692626953,
+                12.257099151611328,
+                12.256779670715332,
+                12.256739616394043,
+                12.260458946228027,
+                12.431501388549805,
+                12.259498596191406,
+                12.259979248046875,
+                12.256778717041016,
+                12.259296417236328,
+                12.254538536071777,
+                12.251660346984863
+            ],
+            "compile_time": 661.5392221137881,
+            "verification_time": 0,
+            "GFLOP/s": 615.6547067627729,
+            "strategy_time": 0,
+            "framework_time": 53.12582431361079,
+            "timestamp": "2023-12-21 10:44:42.236642+00:00"
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/test_convert_files/t4_cache_invalids.json b/test/test_convert_files/t4_cache_invalids.json
new file mode 100644
index 000000000..29587498b
--- /dev/null
+++ b/test/test_convert_files/t4_cache_invalids.json
@@ -0,0 +1,74 @@
+{
+    "schema_version": "1.0.0",
+    "device_name": "",
+    "kernel_name": "convolution_kernel",
+    "problem_size": [
+        4096,
+        4096
+    ],
+    "tune_params_keys": [
+        "block_size_x",
+        "block_size_y",
+        "tile_size_x",
+        "tile_size_y",
+        "read_only",
+        "use_padding",
+        "use_shmem",
+        "use_cmem",
+        "filter_height",
+        "filter_width"
+    ],
+    "tune_params": {
+        "block_size_x": [
+            16
+        ],
+        "block_size_y": [
+            1
+        ],
+        "tile_size_x": [
+            1
+        ],
+        "tile_size_y": [
+            1
+        ],
+        "read_only": [
+            0
+        ],
+        "use_padding": [
+            0
+        ],
+        "use_shmem": [
+            0
+        ],
+        "use_cmem": [
+            1
+        ],
+        "filter_height": [
+            15
+        ],
+        "filter_width": [
+            15
+        ]
+    },
+    "objective": "time",
+    "cache": {
+        "16,1,1,1,0,0,0,1,15,15": {
+            "block_size_x": 16,
+            "block_size_y": 1,
+            "tile_size_x": 1,
+            "tile_size_y": 1,
+            "read_only": 0,
+            "use_padding": 0,
+            "use_shmem": 0,
+            "use_cmem": 1,
+            "filter_height": 15,
+            "filter_width": 15,
+            "time": "CompilationFailedConfig",
+            "compile_time": 661.5392221137881,
+            "verification_time": 0,
+            "strategy_time": 0,
+            "framework_time": 53.12582431361079,
+            "timestamp": "2023-12-21 10:44:42.236642+00:00"
+        }
+    }
+}
diff --git a/test/test_convert_files/t4_target.json b/test/test_convert_files/t4_target.json
new file mode 100644
index 000000000..3bf1a01db
--- /dev/null
+++ b/test/test_convert_files/t4_target.json
@@ -0,0 +1,72 @@
+{
+    "results": [
+        {
+            "timestamp": "2023-12-21 10:44:42.236642+00:00",
+            "configuration": {
+                "block_size_x": 16,
+                "block_size_y": 1,
+                "tile_size_x": 1,
+                "tile_size_y": 1,
+                "read_only": 0,
+                "use_padding": 0,
+                "use_shmem": 0,
+                "use_cmem": 1,
+                "filter_height": 15,
+                "filter_width": 15
+            },
+            "times": {
+                "compilation_time": 661.5392221137881,
+                "framework": 53.12582431361079,
+                "search_algorithm": 0,
+                "validation": 0,
+                "runtimes": [
+                    12.265098571777344,
+                    12.252779960632324,
+                    12.25790023803711,
+                    12.253418922424316,
+                    12.254219055175781,
+                    12.26366138458252,
+                    12.251818656921387,
+                    12.264618873596191,
+                    12.252618789672852,
+                    12.257740020751953,
+                    12.259658813476562,
+                    12.253725051879883,
+                    12.257899284362793,
+                    12.25325870513916,
+                    12.25629997253418,
+                    12.25309944152832,
+                    12.258379936218262,
+                    12.264481544494629,
+                    12.258378982543945,
+                    12.258858680725098,
+                    12.262378692626953,
+                    12.257099151611328,
+                    12.256779670715332,
+                    12.256739616394043,
+                    12.260458946228027,
+                    12.431501388549805,
+                    12.259498596191406,
+                    12.259979248046875,
+                    12.256778717041016,
+                    12.259296417236328,
+                    12.254538536071777,
+                    12.251660346984863
+                ]
+            },
+            "invalidity": "correct",
+            "correctness": 1,
+            "measurements": [
+                {
+                    "name": "time",
+                    "value": 12.262957006692886,
+                    "unit": ""
+                }
+            ],
+            "objectives": [
+                "time"
+            ]
+        }
+    ],
+    "schema_version": "1.0.0"
+}
\ No newline at end of file
diff --git a/test/test_convert_files/too_high_version.json b/test/test_convert_files/too_high_version.json
new file mode 100644
index 000000000..fd1af8ce6
--- /dev/null
+++ b/test/test_convert_files/too_high_version.json
@@ -0,0 +1,4 @@
+{
+    "schema_version": "2.0.0",
+    "field1": "Not a default value"
+}
\ No newline at end of file
diff --git a/test/test_script_ktcache.py b/test/test_script_ktcache.py
new file mode 100644
index 000000000..40870a5e5
--- /dev/null
+++ b/test/test_script_ktcache.py
@@ -0,0 +1,253 @@
+import json
+from pathlib import Path
+from shutil import copyfile
+
+import jsonschema
+import pytest
+
+from kernel_tuner.scripts.ktcache import parse_args
+from kernel_tuner.cache.paths import CACHE_SCHEMAS_DIR
+from kernel_tuner.cache.versions import VERSIONS
+from kernel_tuner.cache.cache import convert_cache_file, read_cache_file
+
+TEST_PATH = Path(__file__).parent
+TEST_CACHE_PATH = TEST_PATH / "test_cache_files"
+TEST_CONVERT_PATH = TEST_PATH / "test_convert_files"
+
+REAL_CACHE_FILE = TEST_CONVERT_PATH / "real_cache.json"
+
+T4_CACHE = TEST_CONVERT_PATH / "t4_cache.json"
+T4_TARGET = TEST_CONVERT_PATH / "t4_target.json"
+
+SCHEMA_NEW = CACHE_SCHEMAS_DIR / str(VERSIONS[-1]) / "schema.json"
+
+
+class TestCli:
+    def test_convert(self, tmp_path):
+        TEST_COPY_SRC = tmp_path / "temp_cache_src.json"
+        TEST_COPY_DST = tmp_path / "temp_cache_dst.json"
+
+        copyfile(REAL_CACHE_FILE, TEST_COPY_SRC)
+
+        parser = parse_args(["convert", "--in", f"{TEST_COPY_SRC}", "--out", f"{TEST_COPY_DST}"])
+
+        parser.func(parser)
+
+        with open(TEST_COPY_DST) as c, open(SCHEMA_NEW) as s:
+            real_cache = json.load(c)
+            real_schema = json.load(s)
+            jsonschema.validate(real_cache, real_schema)
+
+    def test_convert_no_file(self, tmp_path):
+        parser = parse_args(["convert", "--in", "bogus.json"])
+
+        with pytest.raises(FileNotFoundError):
+            parser.func(parser)
+
+    def test_convert_unversioned(self, tmp_path):
+
+        TEST_COPY_UNVERSIONED_SRC = TEST_CACHE_PATH / "small_cache_unversioned.json"
+        TEST_COPY_UNVERSIONED_DST = tmp_path / "small_cache_unversioned.json"
+
+        TEST_COPY_VERSIONED_SRC = TEST_CACHE_PATH / "small_cache.json"
+        TEST_COPY_VERSIONED_DST = tmp_path / "small_cache.json"
+
+        UNVERSIONED_CONVERT_OUT = tmp_path / "small_cache_unversioned_out.json"
+
+        copyfile(TEST_COPY_UNVERSIONED_SRC, TEST_COPY_UNVERSIONED_DST)
+        copyfile(TEST_COPY_VERSIONED_SRC, TEST_COPY_VERSIONED_DST)
+
+        parser = parse_args(["convert", "--in", f"{TEST_COPY_UNVERSIONED_DST}", "--allow-version-absence", \
+                            "-T", "1.0.0", "--out", f"{UNVERSIONED_CONVERT_OUT}"])
+        
+        parser.func(parser)
+
+        convert_result = read_cache_file(UNVERSIONED_CONVERT_OUT)
+        small_content = read_cache_file(TEST_COPY_VERSIONED_DST)
+
+        assert convert_result == small_content 
+
+
+    def test_t4(self, tmp_path):
+        TEST_COPY_DST = tmp_path / "temp_cache_dst.json"
+
+        parser = parse_args(["t4", "--in", f"{T4_CACHE}", "--out", f"{TEST_COPY_DST}"])
+
+        parser.func(parser)
+
+        with open(TEST_COPY_DST) as t4_file, open(T4_TARGET) as t4_target_file:
+            t4 = json.load(t4_file)
+            t4_target = json.load(t4_target_file)
+
+        if t4 != t4_target:
+            raise ValueError("Converted T4 does not match target T4")
+
+    def test_deleteline_invalid_file(self, tmp_path):
+        delete_file = tmp_path / "nonexistent.json"
+
+        parser = parse_args(["delete-line", str(delete_file), "--key", "1"])
+
+        with pytest.raises(FileNotFoundError):
+            parser.func(parser)
+
+    def test_deleteline_invalid_key(self, tmp_path):
+        TEST_SMALL_CACHEFILE_SRC = TEST_CACHE_PATH / "small_cache.json"
+        TEST_SMALL_CACHEFILE_DST = tmp_path / "small_cache.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_SRC, TEST_SMALL_CACHEFILE_DST)
+
+        convert_cache_file(TEST_SMALL_CACHEFILE_DST)
+
+        parser = parse_args(["delete-line", str(TEST_SMALL_CACHEFILE_DST), "--key", "1,1"])
+
+        with pytest.raises(KeyError):
+            parser.func(parser)
+
+    def test_deleteline_valid_key(self, tmp_path):
+        TEST_SMALL_CACHEFILE_THREE_ENTRIES_SRC = TEST_CACHE_PATH / "small_cache_three_entries.json"
+        TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST = tmp_path / "small_cache_three_entries.json"
+
+        TEST_SMALL_CACHEFILE_SRC = TEST_CACHE_PATH / "small_cache.json"
+        TEST_SMALL_CACHEFILE_DST = tmp_path / "small_cache.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_THREE_ENTRIES_SRC, TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+        copyfile(TEST_SMALL_CACHEFILE_SRC, TEST_SMALL_CACHEFILE_DST)
+
+        convert_cache_file(TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+        convert_cache_file(TEST_SMALL_CACHEFILE_DST)
+
+        # Removing key 32,1 from small_cache_three_entries.json should result in small_cache.json
+
+        parser = parse_args(["delete-line", str(TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST), "--key", "32,1"])
+
+        parser.func(parser)
+
+        delete_result = read_cache_file(TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+        small_content = read_cache_file(TEST_SMALL_CACHEFILE_DST)
+
+        assert delete_result == small_content
+
+    def test_getline_invalid_file(self, tmp_path):
+        INPUT_FILE = tmp_path / "nonexistent.json"
+
+        parser = parse_args(["get-line", str(INPUT_FILE), "--key", "1"])
+
+        with pytest.raises(FileNotFoundError):
+            parser.func(parser)
+
+    def test_getline_invalid_key(self, tmp_path):
+        TEST_SMALL_CACHEFILE_SRC = TEST_CACHE_PATH / "large_cache.json"
+        TEST_SMALL_CACHEFILE_DST = tmp_path / "large_cache.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_SRC, TEST_SMALL_CACHEFILE_DST)
+
+        # We know cacheline key 1 is not contained in test_cache_files/large_cache.json
+
+        parser = parse_args(["get-line", str(TEST_SMALL_CACHEFILE_DST), "--key", "1"])
+
+        with pytest.raises(KeyError):
+            parser.func(parser)
+
+    def test_getline_valid_key(self, tmp_path):
+        TEST_SMALL_CACHEFILE_SRC = TEST_CACHE_PATH / "large_cache.json"
+        TEST_SMALL_CACHEFILE_DST = tmp_path / "large_cache.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_SRC, TEST_SMALL_CACHEFILE_DST)
+
+        # We know cacheline key 16,1,1,2,0,0,1,1,15,15 is contained in test_cache_files/large_cache.json
+        parser = parse_args(["get-line", str(TEST_SMALL_CACHEFILE_DST), "--key", "16,1,1,2,0,0,1,1,15,15"])
+
+        parser.func(parser)
+
+    def test_merge_invalid_file(self, tmp_path):
+        INVALID_FILE = tmp_path / "nonexistent.json"
+        INVALID_FILE_TWO = tmp_path / "nonexistent2.json"
+
+        parser = parse_args(["merge", str(INVALID_FILE), str(INVALID_FILE_TWO), "-o", "test.json"])
+
+        with pytest.raises(FileNotFoundError):
+            parser.func(parser)
+
+    def test_merge_nonequiv_key(self, tmp_path):
+        # These files have nonequivalent `device_name`
+        TEST_SMALL_CACHEFILE_SRC = TEST_CACHE_PATH / "small_cache.json"
+        TEST_SMALL_CACHEFILE_DST = tmp_path / "small_cache.json"
+        TEST_LARGE_CACHEFILE_SRC = TEST_CACHE_PATH / "large_cache.json"
+        TEST_LARGE_CACHEFILE_DST = tmp_path / "large_cache.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_SRC, TEST_SMALL_CACHEFILE_DST)
+        copyfile(TEST_LARGE_CACHEFILE_SRC, TEST_LARGE_CACHEFILE_DST)
+
+        parser = parse_args(["merge", str(TEST_SMALL_CACHEFILE_DST), str(TEST_LARGE_CACHEFILE_DST), "-o", "test.json"])
+
+        with pytest.raises(ValueError):
+            parser.func(parser)
+
+    def test_merge_one_file(self):
+        parser = parse_args(["merge", "1.json", "-o", "test.json"])
+
+        with pytest.raises(ValueError):
+            parser.func(parser)
+
+    def test_merge_correct_two_files(self, tmp_path):
+        TEST_SMALL_CACHEFILE_ONE_ENTRY_SRC = TEST_CACHE_PATH / "small_cache_one_entry.json"
+        TEST_SMALL_CACHEFILE_ONE_ENTRY_DST = tmp_path / "small_cache_one_entry.json"
+        TEST_SMALL_CACHEFILE_THREE_ENTRIES_SRC = TEST_CACHE_PATH / "small_cache_three_entries.json"
+        TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST = tmp_path / "small_cache_three_entries.json"
+
+        TEST_SMALL_CACHEFILE_SRC = TEST_CACHE_PATH / "small_cache.json"
+        TEST_SMALL_CACHEFILE_DST = tmp_path / "small_cache.json"
+
+        TEST_MERGE_OUTPUT = tmp_path / "merge_out.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_ONE_ENTRY_SRC, TEST_SMALL_CACHEFILE_ONE_ENTRY_DST)
+        copyfile(TEST_SMALL_CACHEFILE_THREE_ENTRIES_SRC, TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+        copyfile(TEST_SMALL_CACHEFILE_SRC, TEST_SMALL_CACHEFILE_DST)
+
+        # The newly created merge result will use the latest version, so convert the desired result
+        convert_cache_file(TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+
+        # Merging small_cache_one_entry.json and small_cache.json should result in small_cache_three_entries.json
+
+        parser = parse_args(
+            [
+                "merge",
+                str(TEST_SMALL_CACHEFILE_DST),
+                str(TEST_SMALL_CACHEFILE_ONE_ENTRY_DST),
+                "--out",
+                str(TEST_MERGE_OUTPUT),
+            ]
+        )
+
+        parser.func(parser)
+
+        merge_result = read_cache_file(TEST_MERGE_OUTPUT)
+
+        dest_output = read_cache_file(TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+
+        assert merge_result == dest_output
+
+    def test_merge_when_keys_overlap(self, tmp_path):
+        TEST_SMALL_CACHEFILE_ONE_ENTRY_SRC = TEST_CACHE_PATH / "small_cache_one_entry.json"
+        TEST_SMALL_CACHEFILE_ONE_ENTRY_DST = tmp_path / "small_cache_one_entry.json"
+        TEST_SMALL_CACHEFILE_THREE_ENTRIES_SRC = TEST_CACHE_PATH / "small_cache_three_entries.json"
+        TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST = tmp_path / "small_cache_three_entries.json"
+
+        OUT_FILE = tmp_path / "out.json"
+
+        copyfile(TEST_SMALL_CACHEFILE_ONE_ENTRY_SRC, TEST_SMALL_CACHEFILE_ONE_ENTRY_DST)
+        copyfile(TEST_SMALL_CACHEFILE_THREE_ENTRIES_SRC, TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST)
+
+        # We know that small_cache_one_entry.json and small_cache_three_entries.json have overlap for key 32,1
+        parser = parse_args(
+            [
+                "merge",
+                str(TEST_SMALL_CACHEFILE_ONE_ENTRY_DST),
+                str(TEST_SMALL_CACHEFILE_THREE_ENTRIES_DST),
+                "--out",
+                str(OUT_FILE),
+            ]
+        )
+
+        with pytest.raises(KeyError):
+            parser.func(parser)
diff --git a/test/test_util_functions.py b/test/test_util_functions.py
index f3431991b..731707eb5 100644
--- a/test/test_util_functions.py
+++ b/test/test_util_functions.py
@@ -1,8 +1,8 @@
 from __future__ import print_function
 
-import json
 import os
 import warnings
+from datetime import datetime
 
 import numpy as np
 import pytest
@@ -11,6 +11,7 @@
 import kernel_tuner.backends.opencl as opencl
 import kernel_tuner.backends.pycuda as pycuda
 import kernel_tuner.core as core
+from kernel_tuner.cache.cache import Cache
 from kernel_tuner.interface import Options
 from kernel_tuner.util import *
 
@@ -580,21 +581,11 @@ def verify2(answer, result_host, atol):
 
 
 def test_process_cache():
-    def assert_open_cachefile_is_correctly_parsed(cache):
-        with open(cache, "r") as cachefile:
-            filestr = cachefile.read()
-            if filestr[-1] == ",":
-                filestr = filestr[:-1]
-            file_contents = filestr + "}\n}"
-        cache_object = json.loads(file_contents)
-        assert cache_object["device_name"] == "test_device"
-        assert cache_object["kernel_name"] == "test_kernel"
-
     # get temp filename, but remove the file
     cache = get_temp_filename(suffix=".json")
     delete_temp_file(cache)
 
-    kernel_options = Options(kernel_name="test_kernel", problem_size=(1, 2))
+    kernel_options = Options(kernel_name="test_kernel", problem_size=[1, 2])
     tuning_options = Options(
         cache=cache,
         tune_params=Options(x=[1, 2, 3, 4]),
@@ -609,24 +600,27 @@ def assert_open_cachefile_is_correctly_parsed(cache):
 
         # check if file has been created
         assert os.path.isfile(cache)
-        assert_open_cachefile_is_correctly_parsed(cache)
         assert tuning_options.cachefile == cache
-        assert isinstance(tuning_options.cache, dict)
+        assert isinstance(tuning_options.cache, Cache.Lines)
         assert len(tuning_options.cache) == 0
 
         # store one entry in the cache
-        params = {"x": 4, "time": np.float32(0.1234)}
-        store_cache("4", params, tuning_options)
+        tuning_options.cache.append(
+            time=0.1234,
+            compile_time=0.1234,
+            verification_time=0,
+            benchmark_time=0.1234,
+            strategy_time=0,
+            framework_time=0.1234,
+            timestamp=str(datetime.now()),
+            x = 4
+        )
         assert len(tuning_options.cache) == 1
 
-        # close the cache
-        close_cache(cache)
-
         # now test process cache with a pre-existing cache file
         process_cache(cache, kernel_options, tuning_options, runner)
-        assert_open_cachefile_is_correctly_parsed(cache)
 
-        assert tuning_options.cache["4"]["time"] == params["time"]
+        assert tuning_options.cache.get("4").time == 0.1234
 
         # check that exceptions are raised when using a cache file for
         # a different kernel, device, or parameter set