The code has been merged. Therefore, I'm closing this issue.

None from me.

I added a note in issue348 for the convert_global_state problem. 

I guess there are no obstacles to merging this, right?

Thanks! There are two possible sources for the slowdown:

1. the call to convert_state
2. the overhead associated with iteration over the var/val pairs in the goals proxy.

Point 2. might produce some measurable overhead over the old code and could be
reduced by "precomputing" this information, i.e., storing it in instance
variables once during initialization. But I think this is a micro-optimization,
and I don't think it's worth it. In any case, it's clear that 1. dominates the
runtime, and any slowdown we are seeing is caused by this. (That is, even if 2.
were worthwhile, we could not really measure this without addressing the more
import 1. first.)

If I recall correctly, allowing smarter ways of dealing with heuristics that
only need to look at a small subset of the state variables is already on our
radar. Before we do that, we won't get a significant speed-up for the goal-count
heuristic. So I suggest to consider the goal-count heuristic done. If we already
have an issue open for getting rid of the need to always convert the whole
state, then it might sense to mention the goal-count heuristic there as
something to test.

https://bitbucket.org/tkeller/fast-downward/pull-requests/1/issue554/diff

Do we have a link to a diff (or pull request) somewhere? From what I expect the
code for the goal count heuristic to look like, it's probably not worth looking
at the runtimes in much detail.

Looks like h^max actually is faster now, but goal count got a bit slower (not
much but consistently). You could add relative scatter plots to see the details
of that. To do so, copy the file relativescatter.py for example from
experiments/issue582 and then add the following lines to the experiment:

from relativescatter import RelativeScatterPlotReport

exp.add_report(
    RelativeScatterPlotReport(
        attributes=["total_time"],
        filter_config_nick=["gbfs_gc"],
        get_category=lambda run1, run2: run1.get("domain"),
    ),
    outfile='issue554_base_v1_total_time_gc.png'
)

exp.add_report(
    RelativeScatterPlotReport(
        attributes=["total_time"],
        filter_config_nick=["astar_hmax"],
        get_category=lambda run1, run2: run1.get("domain"),
    ),
    outfile='issue554_base_v1_total_time_hmax.png'
)

To me, the results look pretty much identical:
http://ai.cs.unibas.ch/_tmp_files/tkeller/issue554-issue554-issue554-base-issue554-v1-compare.html

All these heuristics should use the task it get from the options object (as a
TaskProxy) instead of the global task. We can handle them in one issue because
the changes required for each one should be minor.