One way to reduce the overhead of concurrency control in a multiprocessor transaction processing system is to implement an underlying synchronization mechanism or a simple global concurrency control directly in hardware. the problem with this approach is that a strong commitment may then be made to a particular synchronization protocol and so the resulting hardware mechanism may be useful in only a very narrow range of systems a solution is possible using a table-driven approach. however a straightforward table-driven approach is impractical due to the extremely large table sizes required for many protocols it is shown here that this problem can be solved by reducing the table sizes required by making use of the processor symmetry that occurs in most systems the resulting algorithm for a table-driven synchronization mechanism is not only general-purpose but also extremely fast an example hardware implementation of this algorithm is presented and practical experience using this approach is described.