I'm currently not planning to pursue this, so I'm closing the issue. Feel free to reopen.

I have recently implemented the canonical heuristic for general abstractions (currently there is code for 
projections and Cartesian abstractions). The implementation uses an int-based representation, which makes evaluation 
faster than the pointer-based implementation in many domains:

http://ai.cs.unibas.ch/_tmp_files/seipp/2017-11-03-B-canonical-heuristic-implementations-no-pruning-abs.html

Correct.

Very interesting, many thanks! issue731 is with the new hash functions but with
the "old" hash table implementation, right? Then hopefully the new hash table
implementation might push us over the hump.

Here are the results from the experiment for issue731-v5:

http://ai.cs.unibas.ch/_tmp_files/seipp/issue731-release32-vs-release64-issue731-v5.html

The total coverage score drops for all three heuristics (blind(), ipdb() and 
cpdbs(systematic(2)) when going from 32-bit to 64-bit (by 12, 3 and 6 tasks). Memory 
usage increases for all configurations (the main culprit for this is probably the hash 
table for the state registry, see issue694). The PDB configurations become faster in 64-
bit mode, while the speed of blind search is only mildly affected.

I'm not sure. Other related issues are issue348, issue536 and issue575. They are
not related to 32 bits vs. 64 bits, but I may just be misremembering this.
Either way, running an experiment sounds good.

Maybe you mean msg5872 in issue213. It contains the link
http://ai.cs.unibas.ch/_tmp_files/seipp/issue213-release32-vs-release64-issue213-v1.html

I just merged the new master into the branch for issue731 and will run the new experiments (testing blind(), ipdb() and 
cpdbs(sys(2))) for issue731-v5 in both 32-bit and 64-bit mode to generate some new data points.

Does someone have a reference for one of the issues where we compared 32-bit to
64-bit configurations and found that some PDB-based configurations are adversely
affected? This information could be a useful starting point for this issue.

Quoting msg6514:

Representing the canonical heuristic with int indices rather than PDB pointers
might be interesting more generally because it may allow us to avoid hash tables
in some other places, too.

I haven't looked at the code, but I vaguely remember that some PDB-based
configurations were among the ones that suffered more than others when switching
to 64 bits. This is often related to the use of hash tables. (I just tried to
find evidence for PDB heuristics doing poorly with 64 bits, but couldn't find
much, so I may be misremembering this.)