/* Copyright (C) 2008-2023 Free Software Foundation, Inc.
   Contributed by Richard Henderson <rth@redhat.com>.

   This file is part of the GNU Transactional Memory Library (libitm).

   Libitm is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   Libitm 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 for
   more details.

   Under Section 7 of GPL version 3, you are granted additional
   permissions described in the GCC Runtime Library Exception, version
   3.1, as published by the Free Software Foundation.

   You should have received a copy of the GNU General Public License and
   a copy of the GCC Runtime Library Exception along with this program;
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
   <http://www.gnu.org/licenses/>.  */

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "libitm_i.h"

// The default TM method used when starting a new transaction.  Initialized
// in number_of_threads_changed() below.
// Access to this variable is always synchronized with help of the serial
// lock, except one read access that happens in decide_begin_dispatch() before
// a transaction has become active (by acquiring the serial lock in read or
// write mode).  The default_dispatch is only changed and initialized in
// serial mode.  Transactions stay active when they restart (see beginend.cc),
// thus decide_retry_strategy() can expect default_dispatch to be unmodified.
// See decide_begin_dispatch() for further comments.
static std::atomic<GTM::abi_dispatch*> default_dispatch;
// The default TM method as requested by the user, if any.
static GTM::abi_dispatch* default_dispatch_user = 0;

void
GTM::gtm_thread::decide_retry_strategy (gtm_restart_reason r)
{
  struct abi_dispatch *disp = abi_disp ();

  this->restart_reason[r]++;
  this->restart_total++;

  if (r == RESTART_INIT_METHOD_GROUP)
    {
      // A re-initializations of the method group has been requested. Switch
      // to serial mode, initialize, and resume normal operation.
      if ((state & STATE_SERIAL) == 0)
	{
	  // We have to eventually re-init the method group. Therefore,
	  // we cannot just upgrade to a write lock here because this could
	  // fail forever when other transactions execute in serial mode.
	  // However, giving up the read lock then means that a change of the
	  // method group could happen in-between, so check that we're not
	  // re-initializing without a need.
	  // ??? Note that we can still re-initialize too often, but avoiding
	  // that would increase code complexity, which seems unnecessary
	  // given that re-inits should be very infrequent.
	  serial_lock.read_unlock(this);
	  serial_lock.write_lock();
	  if (disp->get_method_group()
	      == default_dispatch.load(memory_order_relaxed)
	      ->get_method_group())
	    // Still the same method group.
	    disp->get_method_group()->reinit();
	  serial_lock.write_unlock();
	  // Also, we're making the transaction inactive, so when we become
	  // active again, some other thread might have changed the default
	  // dispatch, so we run the same code as for the first execution
	  // attempt.
	  disp = decide_begin_dispatch(prop);
	  set_abi_disp(disp);
	}
      else
	// We are a serial transaction already, which makes things simple.
	disp->get_method_group()->reinit();

      return;
    }

  bool retry_irr = (r == RESTART_SERIAL_IRR);
  bool retry_serial = (retry_irr || this->restart_total > 100);

  // We assume closed nesting to be infrequently required, so just use
  // dispatch_serial (with undo logging) if required.
  if (r == RESTART_CLOSED_NESTING)
    retry_serial = true;

  if (retry_serial)
    {
      // In serialirr_mode we can succeed with the upgrade to
      // write-lock but fail the trycommit.  In any case, if the
      // write lock is not yet held, grab it.  Don't do this with
      // an upgrade, since we've no need to preserve the state we
      // acquired with the read.
      // Note that we will be restarting with either dispatch_serial or
      // dispatch_serialirr, which are compatible with all TM methods; if
      // we would retry with a different method, we would have to first check
      // whether the default dispatch or the method group have changed. Also,
      // the caller must have rolled back the previous transaction, so we
      // don't have to worry about things such as privatization.
      if ((this->state & STATE_SERIAL) == 0)
	{
	  this->state |= STATE_SERIAL;
	  serial_lock.read_unlock (this);
	  serial_lock.write_lock ();
	}

      // We can retry with dispatch_serialirr if the transaction
      // doesn't contain an abort and if we don't need closed nesting.
      if ((this->prop & pr_hasNoAbort) && (r != RESTART_CLOSED_NESTING))
	retry_irr = true;
    }

  // Note that we can just use serial mode here without having to switch
  // TM method sets because serial mode is compatible with all of them.
  if (retry_irr)
    {
      this->state = (STATE_SERIAL | STATE_IRREVOCABLE);
      disp = dispatch_serialirr ();
      set_abi_disp (disp);
    }
  else if (retry_serial)
    {
      disp = dispatch_serial();
      set_abi_disp (disp);
    }
}


// Decides which TM method should be used on the first attempt to run this
// transaction.  Acquires the serial lock and sets transaction state
// according to the chosen TM method.
GTM::abi_dispatch*
GTM::gtm_thread::decide_begin_dispatch (uint32_t prop)
{
  abi_dispatch* dd;
  // TODO Pay more attention to prop flags (eg, *omitted) when selecting
  // dispatch.
  // ??? We go irrevocable eagerly here, which is not always good for
  // performance.  Don't do this?
  if ((prop & pr_doesGoIrrevocable) || !(prop & pr_instrumentedCode))
    dd = dispatch_serialirr();

  else
    {
      // Load the default dispatch.  We're not an active transaction and so it
      // can change concurrently but will still be some valid dispatch.
      // Relaxed memory order is okay because we expect each dispatch to be
      // constructed properly already (at least that its closed_nesting() and
      // closed_nesting_alternatives() will return sensible values).  It is
      // harmless if we incorrectly chose the serial or serialirr methods, and
      // for all other methods we will acquire the serial lock in read mode
      // and load the default dispatch again.
      abi_dispatch* dd_orig = default_dispatch.load(memory_order_relaxed);
      dd = dd_orig;

      // If we might need closed nesting and the default dispatch has an
      // alternative that supports closed nesting, use it.
      // ??? We could choose another TM method that we know supports closed
      // nesting but isn't the default (e.g., dispatch_serial()). However, we
      // assume that aborts that need closed nesting are infrequent, so don't
      // choose a non-default method until we have to actually restart the
      // transaction.
      if (!(prop & pr_hasNoAbort) && !dd->closed_nesting()
	  && dd->closed_nesting_alternative())
	dd = dd->closed_nesting_alternative();

      if (!(dd->requires_serial() & STATE_SERIAL))
	{
	  // The current dispatch is supposedly a non-serial one.  Become an
	  // active transaction and verify this.  Relaxed memory order is fine
	  // because the serial lock itself will have established
	  // happens-before for any change to the selected dispatch.
	  serial_lock.read_lock (this);
	  if (default_dispatch.load(memory_order_relaxed) == dd_orig)
	    return dd;

	  // If we raced with a concurrent modification of default_dispatch,
	  // just fall back to serialirr.  The dispatch choice might not be
	  // up-to-date anymore, but this is harmless.
	  serial_lock.read_unlock (this);
	  dd = dispatch_serialirr();
	}
    }

  // We are some kind of serial transaction.
  serial_lock.write_lock();
  state = dd->requires_serial();
  return dd;
}


void
GTM::gtm_thread::set_default_dispatch(GTM::abi_dispatch* disp)
{
  abi_dispatch* dd = default_dispatch.load(memory_order_relaxed);
  if (dd == disp)
    return;
  if (dd)
    {
      // If we are switching method groups, initialize and shut down properly.
      if (dd->get_method_group() != disp->get_method_group())
	{
	  dd->get_method_group()->fini();
	  disp->get_method_group()->init();
	}
    }
  else
    disp->get_method_group()->init();
  default_dispatch.store(disp, memory_order_relaxed);
}


static GTM::abi_dispatch*
parse_default_method()
{
  const char *env = getenv("ITM_DEFAULT_METHOD");
  GTM::abi_dispatch* disp = 0;
  if (env == NULL)
    return 0;

  while (isspace((unsigned char) *env))
    ++env;
  if (strncmp(env, "serialirr_onwrite", 17) == 0)
    {
      disp = GTM::dispatch_serialirr_onwrite();
      env += 17;
    }
  else if (strncmp(env, "serialirr", 9) == 0)
    {
      disp = GTM::dispatch_serialirr();
      env += 9;
    }
  else if (strncmp(env, "serial", 6) == 0)
    {
      disp = GTM::dispatch_serial();
      env += 6;
    }
  else if (strncmp(env, "gl_wt", 5) == 0)
    {
      disp = GTM::dispatch_gl_wt();
      env += 5;
    }
  else if (strncmp(env, "ml_wt", 5) == 0)
    {
      disp = GTM::dispatch_ml_wt();
      env += 5;
    }
  else if (strncmp(env, "htm", 3) == 0)
    {
      disp = GTM::dispatch_htm();
      env += 3;
    }
  else
    goto unknown;

  while (isspace((unsigned char) *env))
    ++env;
  if (*env == '\0')
    return disp;

 unknown:
  GTM::GTM_error("Unknown TM method in environment variable "
      "ITM_DEFAULT_METHOD\n");
  return 0;
}

// Gets notifications when the number of registered threads changes. This is
// used to initialize the method set choice and trigger straightforward choice
// adaption.
// This must be called only by serial threads.
void
GTM::gtm_thread::number_of_threads_changed(unsigned previous, unsigned now)
{
  if (previous == 0)
    {
      // No registered threads before, so initialize.
      static bool initialized = false;
      if (!initialized)
	{
	  initialized = true;
	  // Check for user preferences here.
	  default_dispatch = 0;
	  default_dispatch_user = parse_default_method();
	}
    }
  else if (now == 0)
    {
      // No registered threads anymore. The dispatch based on serial mode do
      // not have any global state, so this effectively shuts down properly.
      set_default_dispatch(dispatch_serialirr());
    }

  if (now == 1)
    {
      // Only one thread, so use a serializing method.
      // ??? If we don't have a fast serial mode implementation, it might be
      // better to use the global lock method set here.
      if (default_dispatch_user && default_dispatch_user->supports(now))
	set_default_dispatch(default_dispatch_user);
      else
	set_default_dispatch(dispatch_serialirr());
    }
  else if (now > 1 && previous <= 1)
    {
      // More than one thread, use the default method.
      if (default_dispatch_user && default_dispatch_user->supports(now))
	set_default_dispatch(default_dispatch_user);
      else
	{
	  // If HTM is available, use it by default with serial mode as
	  // fallback.  Otherwise, use ml_wt because it probably scales best.
	  abi_dispatch* a;
#ifdef USE_HTM_FASTPATH
	  if (htm_available())
	    a = dispatch_htm();
	  else
#endif
	    a = dispatch_ml_wt();
	  if (a->supports(now))
	    set_default_dispatch(a);
	  else
	    // Serial-irrevocable mode always works.
	    set_default_dispatch(dispatch_serialirr());
	}
    }
}
