Can stop problem be solved in practice?

In fact, your solution fails to catch simple cases. That is, any program that changes its state without going back is not detected as a possible cause of infinite loop.

Imagine the following program in Java:

public static void main(String[] args) {
    LinkedList<Integer> l = new LinkedList<>();
    while (true) {
      l.add(123);
    }
}

Every time the dump is done, it will be in a new state. Being in a new state, your algorithm to check if it has entered some previously known state goes down the drain. Nothing done. Removing memory limitations and considering addressing with variable/infinite bits, the linked list would grow to infinity without worrying about anything else in that world.

I believe your heuristic would enter a state following static code analysis. If you simply provide the black box of the program, maybe not much more than its automaton in assembly-like format, then we will have a bigger problem. The more basic the form of representation of the program, the closer it is to the Turing machine , the more difficult the static analysis will be.

Another (perhaps even more efficient) heuristic that computational service providers use is to make a timeout available for their execution. If you are dealing with a day-to-day problem, most likely you will be dealing with a class P problem or some heuristic to bring a satisfactory answer even if imperfect, so you need to run fast.

More questions complexes (such as graph isomorphism or even predicting the meta-stable structure of a protein given its amino acid sequence) actually require greater computational power and possibly the heuristic of timeout would give false positives to "eternal execution". This security measure is provided in high-performance computing environments such as the SLURM execution scheduler, to prevent someone from unintentionally passing an impossible-to-solve case and taking the full computational power of a research core. This heuristic is also applied in communication between two distinct machines, since hypothetically you can provide an input that would cause the other machine to go into infinite execution, through the socket read and write timeout.

If with each processor instruction, you dump the 4 Gb of memory (and also the caches, disk, and registers), any programs that are running will eventually repeat a state and you can prove this with the dump. After all, if the memory has a finite size, then the amount of existing states is finite. The stop problem applies to cases where memory is infinite, but that case is the one that has finite memory.

A yes problem stop is (theoretically) solvable in cases where memory is finite by doing exactly what you propose. However, one must look at this "theoretically" quite carefully.

In the worst case, you would have to go through all 2ⁿ memory States until it repeats, where n is the number of bits existing in memory as a whole. If n is a sufficiently small value (for some device with a few bytes of total memory), this until it is feasible. For one typical computer of a few gigabytes of memory, this is totally unviable. If we consider only the 4 Gb of memory and disregard the disks, the number of existing states would be 2^{34.359.738.368} (4 Gb = 34,359,738,368 bits). This results in a number with more than 10 billion decimal digits!

Each Bit of existing memory doubles the amount of possible States and consequently doubles the time and power consumption required for go through all these states. With each byte of memory added, the amount of states increases by 256 times. Now, imagine having 34,359,738,368 bits, each doubling the amount of possible States(this is 4 Gb, and look that this is only the main memory of a computer already considered limited for these days, moreover we are disregarding the disks).

You just can't go through this whole bunch of states because it will take a while and spend a lot energy. Thermodynamic physics will impose barriers before you can finish this. So one of these things happens before:

1. The computer is destroyed by forces external to it.

2. The universe ends before you go through all the states. I don't know if it would be with Big Crunch, Big Rip, Big Freeze, Big Bounce, Heat Death or something else. But whatever the case, it would not be good for you. This implies hypothesis 1 above.

3. You consume all the energy of the universe in order to create and store enough memory dumps (or even if it is just to keep the computer running by going through all these states). This implies hypothesis 2 above which in turn implies hypothesis 1.

Thus, it is not difficult to see that with a sufficient amount of memory, one of the three things listed above would occur (and would occur very early!) in this process.