The reason that the DCPU-16e supports both a global access table (GAT) and a local access table (LAT) is that the DCPU-16e supports multiple memory banks. As such, the global access table provides universal access restrictions (that is, entries apply to every memory bank) while the local access table entries that apply just to the memory bank that the local access table is on. Every memory bank has one local access table.
The DCPU-16e has eight memory banks numbered 000 to 111. There are three ways to use access tables. Firstly, you can simply not use them. This essentially disables the kernel/user mode distinction. If this is done, the INT and RFI instructions behave as they do on the DCPU-16. This is good for learning, but is quite insecure. Secondly, you can choose to only use the global access table. This means that the same access rules are applied to all memory banks equally. Thirdly, you can use both global and local access tables. Note that the local access table address in the global access table is the same for all memory banks, so the local access table is required to be in the same place on every bank.
For example, one might set up the memory layout for a simple multi-user operating system as follows.
The primary memory bank (000) is used exclusively by the kernel, and its local access table is not useful or used. The second memory bank (001) is used exclusively for storage and memory-mapped devices. Filesystem caches and memory-mapped devices can consume a large amount of memory, and keeping that memory in one place can be a useful separation to make. The local access table here would be +rw and -x to avoid accidental code execution. The kernel then uses the remaining memory banks (010-111) for user processes.
The kernel keeps at most six user processes in memory at any one time. Each process gets a whole memory bank, with the exception of any small amount of space the kernel might need to reserve for kernel-process communication code, interrupt handling code, etc. The local access table here is very important, as it prevents the process from reading, modifying or executing sensitive data or code.
The timer device might send an interrupt to the kernel every 10th of a second. When the kernel receives an interrupt, it jumps to the interrupt address. Correct use of the global access table guarantees that the code at the interrupt address is safe. When a device sends an interrupt to the computer, the computer jumps to the IA address and switches to kernel mode. The code at the IA address then switches to the primary memory bank (000) where it performs some operation.
A simple solution to running more than six processes at a time is to page out all of a process's memory whenever another process runs on that bank. However, that's not actually necessary. If two processes share any libraries they can stay loaded into read-only memory, for example, and data can be lazily paged out when the kernel actually needs that space to be used by the new process.