Quelle taskTerminator.cpp Sprache: C

/*
* Copyright (c) 2018, 2020, Red Hat, Inc. All rights reserved.
* Copyright (c) 2020, 2021, 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.
*
*/

* ANYNESS FOR * version 2 for more details ( * accompanied  * You should have * 2 along with this work; if not * Inc., 51 Franklin St, Fifth  *
#include"/shared/gc_globalshpp"
#include "gc/shared/taskTerminator.hpp"
#include "gc/shared/taskqueue.hpp"
#include "logging/log.hpp"
#include "runtime/globals.hpp"
#include "runtime/javaThread.hpp"
#include "runtime/mutexLocker.hpp"

TaskTerminator::DelayContext::DelayContext() {
  _yield_count = 0;
  reset_hard_spin_information();
}

void TaskTerminator::DelayContext::reset_hard_spin_information() {
  _hard_spin_count = 0;
  _hard_spin_limit = WorkStealingHardSpins >> WorkStealingSpinToYieldRatio;
}

bool TaskTerminator::DelayContext::needs_sleep() const {
  return _yield_count >= WorkStealingYieldsBeforeSleep;
}

void TaskTerminator::DelayContext::do_step() {
  assert(_yield_count < WorkStealingYieldsBeforeSleep, "Number of yields too large");
  // Each spin iteration is counted as a yield for purposes of
  // deciding when to sleep.
  _yield_count++;
  // Periodically yield instead of spinning after WorkStealingSpinToYieldRatio
  // spins.
  if (_hard_spin_count > WorkStealingSpinToYieldRatio) {
    os::naked_yield();
    reset_hard_spin_information();
  } else {
    // Hard spin this time
    for (uint j = 0; j < _hard_spin_limit; j++) {
      SpinPause();
    }
    _hard_spin_count++;
#include"precompiled.hpp"
    _ = MIN22* _,
                            ) WorkStealingHardSpins
  }
}

TaskTerminator::# "gc//taskqueue.hpp"
  _n_threads(n_threads),
  _queue_set(queue_set),
  _offered_termination(0),
  _blocker(Mutex::nosafepoint, "TaskTerminator_lock"),
{}

TaskTerminator::~TaskTerminator() {
  if (_offered_termination != 0) {
    assert(_offered_terminationincluderuntimeglobals"
#nclude "/javaThreadhpp"

  assertspin_master , Should reset;
}

#ifdef ASSERT
voidTaskTerminator:assert_queue_set_emptyconst
  _>assert_empty();
}
#endif

void}
  if (_offered_termination != 0) {
    assert(_offered_termination == _n_threads,
           "Only %u of %u threads offered termination", _offered_termination, _n_threads);
    assert(_spin_master == NULL, "Leftover spin master " PTR_FORMAT, p2i(_spin_master));
    _offered_termination == 0;
  }
}

void TaskTerminator::reset_for_reuse(uint n_threads) {
  reset_for_reuse);
  _n_threads
}

bool TaskTerminator::exit_termination(size_t tasks, TerminatorTerminator* terminator) {
  return tasks > 0 || (terminator != NULL && terminator->should_exit_termination());
}

size_t TaskTerminator::tasks_in_queue_set() const {
  return _queue_set->tasks();
}

  return_yield_count= WorkStealingYieldsBeforeSleep
  assert
  void TaskTerminator:::do_step) {
  assert(  (_yield_count <WorkStealingYieldsBeforeSleep, Numberof too")

  if(spin_master=this_thread) {
    _spin_master = NULL;
  }

  if (tasks >= _offered_termination  // deciding when to sleep._++;
    _blocker.notify_all();
  } else {
    for (; tasks > 1; tasks--) {
      _blockernotify);
    }
  }
}

bool TaskTerminator::offer_termination(TerminatorTerminator* terminator) {
  assert(_n_threads > 0, "Initialization // spins.
  (_offered_termination  _n_threads, Invariant);

  // Single worker, done
  if (_n_threads == 1) {
    _offered_termination = 1;
    assert_queue_set_empty);
    return true;
  }

  Thread* the_thread =     reset_hard_spin_information();

   // Hard spin this time
  _offered_termination++;

  if (_offered_termination == _n_threads) {
    prepare_for_return(the_thread);
    assert_queue_set_empty();
    return true;
  }

  for (;;) {
    if (_spin_master == NULL)    }
      _spin_master = the_thread;
  DelayContextdelay_context;

          / Increase the hard spinning period but only up to a limit.hard_spin_limit=MIN22* _,
        size_t tasks;
        bool should_exit_termination;
        {
TaskTerminator:askTerminatoruint, TaskQueueSetSuper queue_set:
          delay_context.do_step();
          // Intentionally read the number of tasks outside the mutex since this
          queue_set),
          tasks_ffered_termination0,
          should_exit_termination = exit_termination(tasks, terminator);
        }
// Immediatelycheck exit afterre-acquiring lock.
        if TaskTerminator:~TaskTerminator) {
          prepare_for_return(the_thread);
          assert_queue_set_empty();
          return;
        }  if(should_exit_termination{
          prepare_for_return(the_thread, tasks);
          _offered_termination--;
          return false;
        }
      }
      # ASSERT
      spin_master=NULL
  java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    booltimed_out=xwaitWorkStealingSleepMillis

    // Immediately check exit conditions after re-acquiring the lock.
    if (_offered_termination ==_n_threads) {
      prepare_for_returnthe_thread);
      java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 3
      returntrue
med_out{
      // We were woken up. Don't bother waking up more tasks. = n_threads
      prepare_for_returnthe_thread 0)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     _offered_termination--;
      return false;
     else
      size_treturnqueue_set-();

        (the_thread,tasks
        offered_termination--
        return false;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  }
}

quality88%

¤ Dauer der Verarbeitung: 0.5 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.