@abstractmethod<EOL><INDENT>def execution_matrix(self, context):<DEDENT>
raise NotImplementedError<EOL>
Describe benchmark commands

        :param context: `ExecutionContext` instance

        Provides list of commands to perform. Every returned command
        is a dictionary containing the following keys:

        * *command*:
            a list of string containing the command to execute.
            Variable substitution is performed on every element
            on the list, using the Python str.format
            method.

            Here is the list of available variables:
                process_count: number of processes to run.
                it provides the --ntasks value when using
                the `srun` execution layer.

            See https://docs.python.org/2/library/stdtypes.html#str.format

        * category*:
            a string used to group commands together.
            Most benchmark class may only need one category.
        * *metas*:
            a dictionary providing relevant information regarding the
            executed command that may be useful afterward. Typically,
            those are command's inputs.
        * *environment* (optional):
            a dictionary providing additional environment variables
            to be given to the executed command
        * *modules* (optional):
            list of modules to load before executed the command.
        * *srun_nodes* (optional):
            When the `srun` execution layer is enabled,
            an integer providing the number of required nodes.
            Must be greater equal than 0 and less than the number of nodes
            of the tag the benchmark is part of.
            If 0, then the job is executed on all nodes of the tag the
            benchmark is part of.
            If a string is provided, then all nodes of the given tag will
            be used.
            Note: this parameter is ignored if -C/--constraint
            slurm option is used.
        * *shell* (optional boolean):
          when `shell` parameter is `True`, then the given command
          is considered as a shell command.
        * *cwd* (optional):
          directory where the command is executed.
        * *expected_exit_statuses* (optional):
          list or set of statuses the command is expected to exit
          to consider it successful.
          Metrics won't be extracted if command fails.
          Default value is: {0}

        Execution context: for every command, a dedicated output directory
        is created and the current working directory changed to this directory
        prior command execution. Standard and error outputs are redirected
        to stdout.txt and stderr.txt respectively. Additional output files
        may be created in this directory.
        Any occurence to "{outdir}" in the command field will be substituted
        by the output directory.

        :return: commands to execute
        :rtype: list of dict. For instance:

        >>> def execution_matrix(self):
            for core in [1, 4, 16, 64]:
                yield dict(
                    category='foo',
                    command=['foo', '--cores', str(cores)],
                    metas=dict(cores=cores),
                )
                yield dict(
                    category='bar',
                    command=['bar', '--cores', str(cores)],
                    metas=dict(cores=cores),
                )