{nonref}Debugging Programs that Manipulate Nodes

Running a program that manipulates nodes can present a problem. The program may create structures (segments, meters, etc.) and in the process loose the capability to examine the created structures. How do we debug the program.

We suggest here running the program in a substitution regime {(p3,sub-regime)} with synthetic nodes {(p3,synnodes)}. The maker of these nodes is in communication with the debugger and can display the inner workings of the nodes.

Suppose that we have segment S and a collection of procedures whose side effects are limited to the modification of a S. These procedures depend only on some constant data {including their code} and S. These procedures call no other procedures. A transaction is the activity of one of these procedures after a call of that procedure and before the return from that call.

We decide to solve the conflict problem by aborting and restarting those transactions that take so long that some of the data that they read changes before the end of the transaction. This strategy shows thru to the callers of the transactions.

In Gnosis terms imagine a set of domains each designed to use read access to some constant data and read-write access to S.

A relation R is kept between the transactions and pages of S. When transaction t reads page p, tRp is made to hold. When a transaction t finishes all tRp's cease holding. When page p is modified, all of the transactions t such that tRp except the one that did the modification are terminated.

Another relation W is kept between the transactions and pages. When transaction t writes page p tWp is made to be true. When a transaction reads a page p then all incomplete transactions t such that tWp are terminated. {So hurry and finish after you have changed pages.} In this case the page is put back to the state it was in at the beginning of ther terminated transaction.

Note that records of terminated or completed transactions need not be kept.

Actions that would terminate transactions can be delayed if a suitable heuristic is available. Indefinite such delays would correspond to traditional interlocks and can cause deadlocks unless specifically avoided.

The relations R and W can be kept by a committee comprised of segment keepers for each of the transactions that manage a segment devoted to that transaction which holds a subset of the pages of S. These keepers must communicate with each other and collectively have the authority to terminate the transactions.

With different hardware this scheme could be made far more efficient than is possible with the 370 architecture.

The first improvement would be to use much smaller pages. A more profound change would be to keep some representation of some subset of R in the hardware.

The procedures that execute these transactions may be written as if they had unlimited access to S and as if one transaction completed before another started.

"a = b+c" is sometimes construed to mean that a is always the sum of b and c. This is not the common meaning in the context of computers. If b or c may change, a is construed as either the sum of prior values, or a reference to a calls for the reevaluation of "b+c". The first meaning is low cost and the second meaning is usually more convenient. Some PDP-10 operating systems are able to ensure that the relocatable form of a program always corresponds to the current version (value) of the symbolic form of the program. In the case of the PDP-10 system the program that uses the relocatable examines the age of the relocatable and symbolic forms of the programs to determine if a recompilation is required. (There is more to come about this.)

Suppose that we have a domain that writes into a segment formatted as an array of 32 bit binary integers and that we have a program that needs read access to an array of 4 byte packed decimal integers with the values corresponding to the first array. A mutual segment keeper may arrange that for each page position, both pages are read-only, or that the first page is read-write while the second page is undefined. Faults for the first segment cause a page from the second segment to be undefined and faults from the second segment cause the page of binary integers to be converted to decimal.

These are special cases of tactics to make sure that information is up-to-date.

See (change-note) for related dilemmas.