def postprocess_results(self):
        """
        When all profiler executables complete, find the best instance
        (min runtime per op name, profiler executable and exec_key (i.e. gemm shape mnk)
        across multiple split_k values)
        The best instance is cached, and written into corresponding gemm nodes in the graph
        """
        target = backend.target.Target.current()
        for _, group in itertools.groupby(
            self._instances,
            key=_profiler_results_groupby_key,
        ):
            min_runtime_results = min(group, key=_profiler_group_reduce_min_key)
            (
                (best_algo, runtime, workspace),
                func_attrs,
                profiler_filename,
                exec_key,
                split_k,
            ) = min_runtime_results

            func_attrs["exec_path"][exec_key].algo = best_algo
            func_attrs["workspace"] = max(func_attrs["workspace"], workspace)
            func_attrs["split_k"] = split_k

            _LOGGER.info(
                f"Profiler ({profiler_filename} {exec_key}) selected kernel: "
                f"{best_algo=} {workspace=} {split_k=}",
            )

            tmp_op = next(iter(func_attrs["op_instance"].values()))
            exec_entry_sha1 = sha1(exec_key.encode("utf-8")).hexdigest()
            cache_record = GemmRecordEntry(
                exec_entry=exec_key,
                exec_entry_sha1=exec_entry_sha1,
                # 1 is subtracted from the type enum values for consistency with the existing
                # cache databases; due to the "void" type being added to the DataType enum as
                # the very first enum member (and shifting the values of other enum members) in
                # https://github.com/NVIDIA/cutlass/commit/7c04f954151f606e60608061e891785fba229ae2
                dtype_a=tmp_op.A.element.value - 1,
                dtype_b=tmp_op.B.element.value - 1,
                dtype_c=tmp_op.C.element.value - 1,
                dtype_acc=tmp_op.accumulator_type().value - 1,
                major_a=tmp_op.A.layout.value,
                major_b=tmp_op.B.layout.value,
                major_c=tmp_op.C.layout.value,
                op_type=func_attrs["op"],
                epilogue=tmp_op.epilogue_functor.value,
                device=target._arch,
                algo=best_algo,
                workspace=workspace,
                split_k=split_k,
                pshape=func_attrs["permute_shape"],
            )
            try:
                target.insert_profile_cache("gemm", cache_record.__dict__)
            except Exception as e:
                _LOGGER.warning(e)

        When all profiler executables complete, find the best instance
        (min runtime per op name, profiler executable and exec_key (i.e. gemm shape mnk)
        across multiple split_k values)
        The best instance is cached, and written into corresponding gemm nodes in the graph
        
python/aitemplate/compiler/ops/gemm_universal/gemm_common.py