Remove redundant memory barrier

[thwuedwin]

This pull request removes an extra memory barrier before queuing AI work. As explained in the commit message, the queue_work() function provides the necessary memory-ordering guarantees, making the explicit barrier redundant under this project’s usage pattern.

The change was tested by running over 1000 games to verify that turn ordering remains strictly alternating between 'O' and 'X'.
However, this testing is not exhaustive. If you know more rigorous methods to validate memory visibility across CPUs, suggestions are welcome.

[jserv]

Write the rationale for the proposed changes based on Linux kernel documentation and source code.

[thwuedwin]

Sorry, I accidentally closed the pull request.
Here is the explanation for the proposed change, based on my understanding of the Linux kernel documentation and source code:

The function queue_work() is defined in /include/linux/workqueue.h, which mentions that it has Memory-ordering properties.

/**
 * queue_work - queue work on a workqueue
 * Memory-ordering properties:  If it returns %true, guarantees that all stores
 * preceding the call to queue_work() in the program order will be visible from
 * the CPU which will execute @work by the time such work executes, e.g.,
 * ...
 */
static inline bool queue_work(struct workqueue_struct *wq,
			      struct work_struct *work)
{
	return queue_work_on(WORK_CPU_UNBOUND, wq, work);
}

The underlying function queue_work_on() is defined in /kernel/workqueue.c. It queues the given work on the specified CPU, if it is not already pending. Its return value is false if the work is already in a queue, and true otherwise.

    if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) &&
        !clear_pending_if_disabled(work)) {
        __queue_work(cpu, wq, work);
        ret = true;
    }

Inside clear_pending_if_disabled(), we can find a call to set_work_pool_and_clear_pending(), which uses a memory barrier smp_wmb() to ensure proper visibility of prior stores.

However, the first condition uses test_and_set_bit() to check and set the pending bit. Suppose the bit was already set (i.e., the work item is already enqueued). In that case, the short-circuiting behavior of the logical && operator prevents evaluation of the second condition and therefore skips the memory barrier. In such a case, queue_work_on() returns false, and the memory-ordering guarantee does not apply.

This means the memory-ordering property holds when the work is successfully queued, which is guaranteed in this project.