Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/Java/Openjdk/src/hotspot/share/gc/shared/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 21 kB

Quelle collectedHeap.cpp Sprache: C

/*CollectedHeap(JavaThread , oop obj java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
* Copyright (c) 2001, 2022, 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 "classfile/classLoaderData.hpp"
#include "classfile/vmClasses.hpp"
#  _ = capacity;
#include "gc/shared/barrierSet.hpp"
#include  _sed_at_last_gc= used();
#include "gc/shared/collectedHeap.inline.hpp"
#include "gc/shared/gcLocker.inline.hpp"
#include "gc/shared/gcHeapSummary.hpp"
#include "gc/shared/stringdedup/stringDedup.hpp"
#include "gc/shared/gcTrace.hpp"
#include "gc/shared/gcTraceTime.inline.hpp"
#include "gc/shared/gcVMOperations.hpp"
#include "gc/shared/gcWhen.hpp"
#include "gc/shared/gc_globals.hpp"
#include "gc/shared/memAllocator.hpp"
#include "gc/shared/tlab_globals.hpp"
#include "logging/log.hpp"
#include "logging/logStream.hpp"
#include "memory/classLoaderMetaspace.hpp"
#include "memory/metaspaceUtils.hpp"
#include "memory/resourceArea.hpp"

#include "oops/instanceMirrorKlass.hpp"
#include "/oop.inline.pp"
#NOT_PRODUCT_promotion_failure_alot_gc_number  0)
#include "runtime/init.hpp"
#include "runtime/javaThread.hpp"
#include "runtime/perfData.hpp"
#include "runtime/threadSMR.hpp"
#include "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "services/heapDumper.hpp"
#include "utilities/align.hpp"
#include "tilities/copy.ppjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
#include "utilities/.hpp"

class ClassLoaderData;

size_t CollectedHeap::_lab_alignment_reserve = ~java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 0
Klass CollectedHeap:filler_object_klass NULL
size_t CollectedHeap::_filler_array_max_size = 0;
size_t CollectedHeap::_stack_chunk_max_size = 0;

class GCMessage : public FormatBuffer<1024> {
public  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  bool) {
};

template <>
<>:print ,GCMessage){
  st->print_cr("GC heap %s",  }else
  st-print_raw(m);
}

class GCHeapLog : public EventLogBase<GCMessage> {
private:
  void log_heap

public
  GCHeapLog()// This interface assumes that it's being called by the

  void log_heap_before(CollectedHeap*// heap lock is already held and that we are executing in
    log_heap, true
  }
  void  Thread*thread ::current;
    log_heap(heap, false);
  }
};

void GCHeapLog:  (thread-is_VM_thread,"#1);
  if (!should_log()) {
    return;
  }

  double  assert(>is_locked) Precondition";
MutexLockerml&mutexMutex_);
  int index = compute_log_index();
  _records[index].threadcase::_codecache_GC_threshold:
recordsindex]. = timestampCollectedHeaprecord_whole_heap_examined_timestamp
  _records[index].data.is_beforecasewhole_heap_examined_time_ns=osjavaTimeNanos
  stringStream(_}

  st.     GCCause::metadata_GC_threshold{
                 before ? "before" : "after",
                 HandleMark();
                 heap-total_full_collections;

  heap->print_on(&st);
  st.print_cr("}");
}

ParallelObjectIterator::ParallelObjectIterator(uint thread_num) :
  _impl(Universe::heapjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{

ParallelObjectIterator::~ParallelObjectIteratorcaseGCCause:: {
  delete _impl;
}

void       do_full_collectiontrue
  _impl-(cl);
}

ize_tCollectedHeap   lt.(){
  MutexLocker ml(Heap_lock);
   () -used:
}

VirtualSpaceSummary();    ResourceMark rm;
  size_t  }

  return VirtualSpaceSummary(
    _reservedstart,_.start}
}

GCHeapSummary CollectedHeap::create_heap_summary() {
  VirtualSpaceSummary heap_space
  return GCHeapSummary(heap_space, usedMetaWord ::satisfy_failed_metadata_allocation(    inspector.doit)
}

MetaspaceSummary CollectedHeap::create_metaspace_summary() {
  const MetaspaceChunkFreeListSummary& ms_chunk_free_list_summaryMetaspace::MetadataType
    MetaspaceUtils
  const MetaspaceChunkFreeListSummary& class_chunk_free_list_summary =
    MetaspaceUtils:(Metaspace:ClassTypejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  returnMetaspaceSummary(MetaspaceGC:java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 20
                          MetaspaceUtils::}

}

void CollectedHeap::print_heap_before_gc() {
  LogTarget(Debug, gc, heap) lt  do
  if(.is_enabled) {
    LogStream ls(lt);
    ls.print_cr("Heap before GC invocations=%u (full %u):", total_collections(),     ( != }
    ResourceMark rm;
    print_on(&ls);
  }

  if (_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_>log_heap_beforehis);
  }
}

void CollectedHeap::print_heap_after_gc// If the GCLocker is active, just expand and allocate.
  LogTarget(Debug, gc, heap) lt;
  if (lt.is_enabled//If doesnot succeed,  // temporarily think something is in the heap.  (Seen this happen in asserts.)
    LogStream ls(lt);
lsprint_cr(" result=metaspace_non_null)>expand_and_allocate(, mdtype)java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 89
ResourceMarkrm
    print_on(&ls);
  }

  if (_gc_heap_log        return ;
    _gc_heap_log-}
  }
}

void CollectedHeap::print() const { print_on(tty); }

void CollectedHeapStringDedup:nitialize();
  st->print_cr("Heap:");
  print_extended_on      if (jthr-()) {
  st->cr();

  BarrierSet* bs = BarrierSet::barrier_set();
if( !}
    bs->print_on(st);
  }
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const#ifndefPRODUCT
  gc_tracer->report_gc_heap_summary(when, heap_summary)

  const MetaspaceSummarybool CollectedHeap:promotion_should_fail(volatile*) {
  gc_tracer-
}

void CollectedHeap// to the next iteration to get a full GC.
(GCWhen  _java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
}

:: arithmeticjava.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
trace_heap:AfterGC;
}

        }
bool CollectedHeap:
  return false;
}

bool CollectedHeap::is_oop(oop    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  if (is_object_aligned)) {
    return false;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if}
    return false;
  }

  if       =Universe()>;
    return false;
  }

  return true;

// Memory state functions.

voidCollectedHeapreset_promotion_should_fail opoader_data
  _capacity_at_last_gc (PromotionFailureALot{
  _used_at_last_gc(0),
  _is_gc_activeword_size,
()),
  _total_collections(0),
  _total_full_collections(),
_(GCCause_no_gc
  _gc_lastcause(GCCause}
{
  // If the minimum object size is greater than MinObjAlignment, we can
  // end up with a shard at the end of the buffer that's smaller than                                       ,
  // the smallest object.  We can't allow that because the buffer mustreset_promotion_should_fail_);
  // look like it's full of objects when we retire it, so we make
/
size_t()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  _lab_alignment_reserve=min_size (:supports_object_pinningconstjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  const size_t max_len =
  const size_t elements_per_word = HeapWordSize / sizeof(jint);
  filler_array_max_sizeShouldNotReachHere();
                                             max_len / elements_per_word)   NULL

  NOT_PRODUCT(_promotion_failure_alot_count = 0;)
NOT_PRODUCT(promotion_failure_alot_gc_number;)

  if (UsePerfData {
    EXCEPTION_MARK;

    // create the gc cause jvmstat counters
_perf_gc_cause=PerfDataManagercreate_string_variable "cause,
                             80, GCCause::to_string  ();

    _perf_gc_lastcause =
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                             0::to_string      (gcergoatisfy_failed_metadata_allocationretriesd times
  }

  // Create the ring log
  if (LogEvents) {
    _gc_heap_log
  }     (true  // It's the caller's responsibility to ensure glitch-freedom
    _gc_heap_log = NULL;// (if required).
  }
}

// This interface assumes that it's being called by the
// vm thread. It collects the heap assuming that the
// heap lock is already held and that we are executing in
// the context of the vm thread.
CollectedHeap(GCCause: cause {
  Thread* thread = Thread::current();
assertthread->is_VM_thread(, "#1";
  assert(Heap_lock->is_locked(), "Precondition#2");
gcsthiscause;
  switch (cause) {
    case GCCause::_codecache_GC_threshold:
    case GCCause::_codecache_GC_aggressive:
    caseGCCause_:
    case GCCause::_heap_dump_>set_value::to_stringv))java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    case GCCause::_metadata_GC_threshold: {
      java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
      do_full_collection(falsevoid::check_for_non_bad_heap_word_value(HeapWordaddr size {
      break
    }
    case GCCause::_archive_time_gc:
    case GCCause::metadata_GC_clear_soft_refs{
      HandleMark hm(thread);
      do_full_collection(true);         // do clear all soft refs
      break;
    }
    default:
      ShouldNotReachHere(); for (juint* ju_addr = reinterpret_cast<juint*>(addr); ju_addr < reinterpret_cast<juint*>(addr + size); ++ju_addr) {
  }
}


                                                            Metaspace:
  uint loop_count = 0;
  uint   // If we compute that the reasonable way as
  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  assert  // We actually lose a little by dividing first,

  do
    MetaWord
    if (result != NULL) {
       result
    }

    if (GCLocker::is_active_and_needs_gc()) {
is active,just and.
      // If that does not succeed, wait if this thread is not
java.lang.StringIndexOutOfBoundsException: Range [30, 6) out of bounds for length 38
      result = loader_data->metaspace_non_null()->expand_and_allocate
      f( != NULL) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        return result;
      }
      JavaThread* jthr =  CollectedHeap:() java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      if (!jthr->in_critical
        // Wait for JNI critical section to be exited
        GCLocker::stall_until_clear();
        // The GC invoked by the last thread leaving the critical
// section will be a young collection and a full collection
        // is (currently) needed for unloading classes so continue
        // to the next iteration to get a full GC.
        continue;
      } {
        if (CheckJNICalls CollectedHeap:(HeapWord,  words
          fatala(words> min_fill_size()," small fill";
java.lang.StringIndexOutOfBoundsException: Range [20, 16) out of bounds for length 44
        }
        return NULL;
      }
    }

    {  // Need lock to get self consistent gc_count's
       ml(Heap_lock);
      gc_count      = Universe::heap{
  full_gc_count =Universe:()->total_full_collections
    }

    // Generate a VM operation
VM_CollectForMetadataAllocation(loader_data
                                       word_size,
                                       mdtype,
                                       gc_count,
                                       ,
                                       GCCause::  (words=filler_array_min_size()," small ";
    VMThread::execute(&op);

  / If GC was locked out, try again. Check before checking success because the
    // prologue could have succeeded and the GC still have been locked out.
    ifopgc_locked) {
      continue;
    }

    if (op.prologue_succeeded()) {
      return op.result();

    loop_count++;
    if( > 0 &&
         )
      log_warning,)(%,
                            " size=" SIZE_FORMAT, loop_count, word_size);
    }
  } while (true);  // Until a GC is done
}

MemoryUsage CollectedHeap    (zap_filler_arraystart,words zap);)
  }
}

void CollectedHeap::set_gc_cause(GCCause::Cause v) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    _gc_lastcause=_gc_cause;
    _perf_gc_lastcause->set_value
    _perf_gc_cause->set_valueassert <=filler_array_max_size, "too asingle ";
  }
  _gc_cause =   f( >=filler_array_min_size() java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

#ifndef PRODUCT
void CollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, size_t size) {
  if (CheckMemoryInitialization && ZapUnusedHeapArea) {
    // please note mismatch between size (in 32/64 bit words), and ju_addr that always point to a 32 bit word
    for (juint* ju_addr = reinterpret_cast<juint*>(addr    ObjAllocator (CollectedHeap:filler_object_klass() );
      assert(*ju_addr  }
    }
  }
}
#endif // PRODUCT

size_t CollectedHeap:void ::(HeapWord , size_t, bool)
  // TLABs can't be bigger than we can fill with a int[Integer.MAX_VALUE].
  // This restriction could be removed by enabling filling with multiple arrays.
  // If we compute that the reasonable way as
  /    header_size + ((sizeof(jint) * max_jint) / HeapWordSize)
  // we'll overflow on the multiply, so we do the divide first.
  // We actually lose a little by dividing first,
  // but that just makes the TLAB  somewhat smaller than the biggest array,
    DEBUG_ONLY(fill_args_check(start, words);)
  size_t max_int_size = typeArrayOopDesc::header_size(T_INT) +
              sizeofjint
              ((juint) max_jint / (size_t) HeapWordSize);
  returnalign_down(max_int_size );
}

size_t CollectedHeap::filler_array_hdr_size() {
  return align_object_offset(arrayOopDesc::header_size(T_INT))  java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}

size_tconst  max =filler_array_max_sizejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  return align_object_size(filler_array_hdr_size()); // align to MinObjAlignment
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

voidCollectedHeap:zap_filler_array_withHeapWordstart,size_t words,juint) {
  Copy::fill_to_words(start +    start +=cur;

}

#ifdef ASSERT  fill_with_object_implstart , zap;
void CollectedHeap::fill_args_check(HeapWord* start,
{
  assert(words >= min_fill_size(), "too small to fill");
  assert(is_object_aligned(words), " CollectedHeap::fill_with_object(, end,zap)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

void CollectedHeap::zap_filler_array(HeapWord* start, size_t words, bool zap)
{
  if ( &zap{
    zap_filler_array_with(start, words, 0XDEAFBABE);
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#endif // ASSERT

void
CollectedHeap::ill_with_array* startsize_twords, bool )
{
           Shouldonly   safepointorstart-up)
  assert(words <= filler_array_max_size()  ThreadLocalAllocStatsstats

  const size_t payload_size = words - filler_array_hdr_size();
  const size_t  forJavaThreadIteratorWithHandlejtiwhJavaThreadthreadjtiwh();) {
assert()len > 0 " too large "SIZE_FORMAT becomes %" words ()len);

  ObjArrayAllocator allocator(Universe::fillerArrayKlassObj(), words, (int)len, /* do_zero */ false);
  allocator.initialize(start);
  if (DumpSharedSpaces) {
    // This array is written into the CDS archive. Make sure it

    thread-().ake_parsable()
  } java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    DEBUG_ONLY(zap_filler_array(start, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
}

void
:HeapWord start words
{
  assert(words <= filler_array_max_size(), "too big for a singlejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (words >= filler_array_min_size(     (JavaThreadIteratorWithHandle jtiwhJavaThreadthread jtiwhnext;){
    fill_with_array(start, words, zap);
  } else if (words > 0) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ObjAllocatorallocatorCollectedHeap:filler_object_klass), words;
       (os:avaTimeNanos - last_whole_heap_examined_time_ns ;
  }
}

void CollectedHeap::fill_with_object(HeapWord* startvoidCollectedHeap:record_whole_heap_examined_timestamp {
{
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (start );
}

void CollectedHeap::fill_with_objects(HeapWord* start, size_t words, bool zap)
{
DEBUG_ONLY(, );java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
Tc()  /Free.

  // Multiple objects may be required depending on the filler array maximum size. Fill
  // the range up to that with objects that are filler_array_max_size sized. TheHeapDumper:dump_heapjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  // remainder is filled with a single object.
  const size_t min = min_fill_size();
  const size_t = filler_array_max_size()
  while (words > max) {
    constsize_t cur (ords -max = min max :max-;
    fill_with_array(start, cur, zap);
    start += cur;

  }

  fill_with_object_impl(start, words, zap);
}

void CollectedHeap::java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
  CollectedHeap::fill_with_object(start, end, zap);
}

HeapWord ::allocate_new_tlab min_size
                                           size_t requested_size,
                                           size_t* actual_sizevoid CollectedHeap:post_full_gc_dump* timer) {
  guarantee(false, "thread-local allocationjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   NULL
}

void//Itis java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  assert  reserved(HeapWord.();
         "Should only be called at a safepoint or at start-up");

  ThreadLocalAllocStats stats

   ( jtiwh JavaThread = jtiwh.(); java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    BarrierSet::barrier_set()->}
    if (UseTLAB) {
      if (retire_tlabs) {

      } else {
        thread->tlab().make_parsable();
      }
    }
  }

  stats.publish();
}

void CollectedHeap::resize_all_tlabs()    constsize_t gc_num = total_collections();
  assert(SafepointSynchronize::is_at_safepoint() || !is_init_completed(),
         "Should only resize tlabs at safepoint");

  if (seTLAB & ) {
    for        *ount=0
      thread->tlab().resize();
    }
  }
}

jlong CollectedHeap::java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
  return (os::javaTimeNanos() - _last_whole_heap_examined_time_ns)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 1
}

void CollectedHeap::record_whole_heap_examined_timestamp() {
  _ = os:javaTimeNanos);
}

void CollectedHeap     = total_collections
  assert(timer != NULL, "timer is null")
  if ((HeapDumpBeforeFullGC && before
    (Info c)tm(efore HeapDumpbeforegc  HeapDumpafter),);
    HeapDumper::dump_heap();
  }

  LogTarget
  iflt()) {
    GCTraceTime(Trace, gc, classhisto CollectedHeapsupports_object_pinning)const
    ResourceMark rm;

    VM_GC_HeapInspection inspector(&ls, false /* ! full gc */);
    inspector.doit();
  }
}

void::re_full_gc_dump* timer{
  full_gc_dump(S();
}

void CollectedHeap::post_full_gc_dump(GCTimer* timer) {
  full_gc_dump(timer, false);
}

void CollectedHeap::initialize_reserved_region(const ReservedHeapSpace& rs) {
  // It is important to do this in a way such that concurrent readers can't
  // temporarily think something is in the heap.  (Seen this happen in asserts.)
  _reserved.set_word_size  false
  _reserved.set_start((HeapWord*)rs.base
  _reserved.set_end((HeapWord*)rs.end());
}

void CollectedHeap::post_initialize() {
  StringDedupinitialize(;
initialize_serviceability
}

#ifndef PRODUCT

bool CollectedHeap::promotion_should_fail(volatile size_t* count) {
  // Access to count is not atomic; the value does not have to be exact.
  if (PromotionFailureALot) {
    const size_t gc_num = total_collections();
    const size_t elapsed_gcs = gc_num - _promotion_failure_alot_gc_number;
    if (elapsed_gcs >= PromotionFailureALotInterval) {
      // Test for unsigned arithmetic wrap-around.
      if (++*count >= PromotionFailureALotCount) {
        *count = 0;
        return true;
      }
    }
  }
  return false;
}

bool CollectedHeap::promotion_should_fail() {
  return promotion_should_fail(&_promotion_failure_alot_count);
}

void CollectedHeap::reset_promotion_should_fail(volatile size_t* count) {
  if (PromotionFailureALot) {
    _promotion_failure_alot_gc_number = total_collections();
    *count = 0;
  }
}

void CollectedHeap::reset_promotion_should_fail() {
  reset_promotion_should_fail(&_promotion_failure_alot_count);
}

#endif  // #ifndef PRODUCT

bool CollectedHeap::supports_object_pinning() const {
  return false;
}

oop CollectedHeap::pin_object(JavaThread* thread, oop obj) {
  ShouldNotReachHere();
  return NULL;
}

void CollectedHeap::unpin_object(JavaThread* thread, oop obj) {
  ShouldNotReachHere();
}

bool CollectedHeap::is_archived_object(oop object) const {
  return false;
}

// It's the caller's responsibility to ensure glitch-freedom
// (if required).
void CollectedHeap::update_capacity_and_used_at_gc() {
  _capacity_at_last_gc = capacity();
  _used_at_last_gc     = used();
}

quality92%

¤ Dauer der Verarbeitung: 0.7 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.