/*

 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "runtime/atomic.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/os.hpp"

#include "utilities/debug.hpp"

#include "utilities/singleWriterSynchronizer.hpp"

#include "utilities/macros.hpp"

SingleWriterSynchronizer::SingleWriterSynchronizer() :

  _enter(0),

  _exit(),

  // The initial value of 1 for _waiting_for puts it on the inactive

  // track, so no thread exiting a critical section will match it.

  _waiting_for(1),

  _wakeup()

  DEBUG_ONLY(COMMA _writers(0))

{}

// Wait until all threads that entered a critical section before

// synchronization have exited that critical section.

void SingleWriterSynchronizer::synchronize() {

  // Side-effect in assert balanced by debug-only dec at end.

  assert(Atomic::add(1u, &_writers) == 1u, "multiple writers");

  // We don't know anything about the muxing between this invocation

  // and invocations in other threads.  We must start with the latest

  // _enter polarity, else we could clobber the wrong _exit value on

  // the first iteration.  So fence to ensure everything here follows

  // whatever muxing was used.

  OrderAccess::fence();

  uint value = _enter;

  // (1) Determine the old and new exit counters, based on the

  // polarity (bit0 value) of the on-entry enter counter.

  volatile uint* new_ptr = &_exit[(value + 1) & 1];

  // (2) Change the in-use exit counter to the new counter, by adding

  // 1 to the enter counter (flipping the polarity), meanwhile

  // "simultaneously" initializing the new exit counter to that enter

  // value.  Note: The new exit counter is not being used by read

  // operations until this change of _enter succeeds.

  uint old;

  do {

    old = value;

    *new_ptr = ++value;

    value = Atomic::cmpxchg(value, &_enter, old);

  } while (old != value);

  // Critical sections entered before we changed the polarity will use

  // the old exit counter.  Critical sections entered after the change

  // will use the new exit counter.

  volatile uint* old_ptr = &_exit[old & 1];

  assert(old_ptr != new_ptr, "invariant");

  // (3) Inform threads in in-progress critical sections that there is

  // a pending synchronize waiting.  The thread that completes the

  // request (_exit value == old) will signal the _wakeup semaphore to

  // allow us to proceed.

  _waiting_for = old;

  // Write of _waiting_for must precede read of _exit and associated

  // conditional semaphore wait.  If they were re-ordered then a

  // critical section exit could miss the wakeup request, failing to

  // signal us while we're waiting.

  OrderAccess::fence();

  // (4) Wait for all the critical sections started before the change

  // to complete, e.g. for the value of old_ptr to catch up with old.

  // Loop because there could be pending wakeups unrelated to this

  // synchronize request.

    _wakeup.wait();

  }

  // (5) Drain any pending wakeups. A critical section exit may have

  // completed our request and seen our _waiting_for before we checked

  // for completion.  There are also possible (though rare) spurious

  // wakeup signals in the timing gap between changing the _enter

  // polarity and setting _waiting_for.  Enough of any of those could

  // lead to semaphore overflow.  This doesn't guarantee no unrelated

  // wakeups for the next wait, but prevents unbounded accumulation.

  while (_wakeup.trywait()) {}

  DEBUG_ONLY(Atomic::dec(&_writers);)

}