The table buffers reside locally on each application server in the system. However, this makes it necessary for the buffer administration to transfer all changes made to buffered objects to all the application servers of the system.

If a buffered table is modified, it is updated synchronously in the buffer of the application server from which the change was made. The buffers of the whole network, that is, the buffers of all the other application servers, are synchronized with an asynchronous procedure.

Entries are written in a central database table (DDLOG) after each table modification that could be buffered. Each application server reads these entries at fixed time intervals.

If entries are found that show a change to the data buffered by this server, this data is invalidated. If this data is accessed again, it is read directly from the database. In such an access, the table can then be loaded to the buffer again.

To prevent a table being constantly loaded to the buffer and then immediately invalidated there, the table can only be loaded again to the buffer after a waiting time following invalidation.

The advantage of this method over a synchronous method (where the network immediately reports each change to buffered data of one server to all the other servers) is that the load on the network is kept to a minimum. If the buffers were to be synchronized after each modification, each server would have to report each modification to a buffered table to all the other servers using the network. This would have a negative effect on the performance.

The disadvantage of this method as compared with synchronous updating is that the data will not be up-to-date during the time interval between two synchronizations.

Because of the asynchronous buffer synchronization method, you should note the following when setting the table buffering:

• Only tables that are rarely written (read mostly) or for which temporary inconsistencies are of no significance should be buffered.
• Tables whose entries are frequently modified should not be buffered. Otherwise there would be constant invalidation and reloading, which would have a negative effect on the performance.