Three Proposals for Future Core War Standards by Jon Newman These proposals address some problems with past and current standards and the kinds of fighter programming they promote. I have not implemented or tested the last two, and cannot recommend that they be adopted without some practical experience. [ps: I have implemented them but have not done significant fighter development on them.] (1) The Process Count Modification Most simulators specify a maximum number of processes on a side, either explicitly or implicitly (through limited available memory). However, the ICWS '88 standard assumes that the number of processes on a side is unbounded, or at least does not specify program behavior when this limit is reached. This modification provides a sound basis for the practically necessary process count limitation; in effect, it codifies the behavior of existing simulators. The modification is trivial; when a fighter is loaded into memory, a maximum process count for that side is explicitly or implicitly provided. When the number of processes on that side is at the limit, the SPL instruction has no effect; no new process is created, and the existing process continues with the next instruction. No additional syntax is provided for a fighter program to supply its own maximum process count; maximum process count is a constant for the tournament. (2) The Address Space Modification Since the '87 contest, we have seen that many or most successful fighters are entirely stationary; they do not move around in core, nor do they split off new processes. These fighters are effective because they spend all of their time attacking and none copying themselves, and because they present a small target; they can be killed with one hit, but then almost any program can be completely disabled with one hit by a SPL 0,0 bomb. While such fighters are entirely legal, I find them rather less interesting than programs like MICE. The address space modification forces programs to move around in core in order to seek out and destroy their opponents. The address space modification is simple, and requires no changes in the REDCODE language. Instead of allowing any operand to address any location in core, we restrict operand fields to some smaller range. For example, with CORESIZE=8192 and ADDRESS_SPACE=2048, operand fields would be restricted to the range -1024..1023; if we add #1 to DAT -1,1027, the result is DAT 0,-1028. As usual, all address arithmetic is modulo CORESIZE. The effect of this modification with these parameters is that any instruction can only directly access 1/4 of the core array, or 1/2 of the core array using indirection; if a program intends to seek out opponents anywhere in core, it will have to copy itself around or split off new processes in other locations. Why is this modification called "address space"? Many real computers distinguish between their "logical" address space (the memory which can be addressed by a program) and their "physical" address space (the amount of RAM actually available in the computer). Typically, the "logical" address space is larger; if a program references a logical location which is not currently available in physical memory, that information is brought into physical memory from backing store (usually a fast disk). (I am vastly oversimplifying.) Our modification to Core War follows this model, except that the "physical" address space is larger than the "logical" address space; from any given memory location, there are certain other memory locations for which there is no logical address. (3) The Descendant Count Modification Under current and prior standards, any process can split off an arbitrary number of processes (up to the process count limit). This gives spl 0,0 bombs and vampiric capture devastating effect; such attacks can effectively halt all processing on a side, even by processes which were not directly hit. The Descendant Count Modification is intended to limit the effectiveness of these attacks somewhat, by allowing a side to specify the maximum number of descendants of any new process. This modification is highly experimental; I cannot claim to really know how it will behave. When a new process is created, the B-operand of the SPL instruction specifies the maximum number of descendants of the new process. We maintain a "tree" of existing processes and their associated descendant count limits, where this tree structure is separate from the process queue. If creating a new process would violate the descendant count limit of the parent process, or of its parent process, etc., then no new process is created. When some process X dies, its children become the children of X's parent. The descendant count limit of the original process is MAXINT; all "root" processes are logically children of an imaginary "super-root" with a descendant count limit equal to the process count limit. Note that any process can change its process count limit by splitting off a new process and then committing suicide, provided it can split off another process.