settings.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2007-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library 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, or (at your option) any later
// version.

// This library 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/>.

// Written by Johannes Singler and Felix Putze.

#ifndef _GLIBCXX_PARALLEL_SETTINGS_H
#define _GLIBCXX_PARALLEL_SETTINGS_H 1

#include <parallel/types.h>

#define _GLIBCXX_PARALLEL_CONDITION(__c) \
  (__gnu_parallel::_Settings::get().algorithm_strategy \
    != __gnu_parallel::force_sequential \
  && ((__gnu_parallel::__get_max_threads() > 1 && (__c)) \
     || __gnu_parallel::_Settings::get().algorithm_strategy \
        == __gnu_parallel::force_parallel))

/*
inline bool
parallel_condition(bool __c)
{
  bool ret = false;
  const _Settings& __s = _Settings::get();
  if (__s.algorithm_strategy != force_seqential)
    {
      if (__s.algorithm_strategy == force_parallel)
        ret = true;
      else
        ret = __get_max_threads() > 1 && __c;
    }
  return ret;
}
*/

namespace __gnu_parallel
{
  struct _Settings
  {
    _AlgorithmStrategy          algorithm_strategy;
    
    _SortAlgorithm              sort_algorithm;
    _PartialSumAlgorithm        partial_sum_algorithm;
    _MultiwayMergeAlgorithm     multiway_merge_algorithm;
    _FindAlgorithm              find_algorithm;

    _SplittingAlgorithm         sort_splitting;
    _SplittingAlgorithm         merge_splitting;
    _SplittingAlgorithm         multiway_merge_splitting;

    // Per-algorithm settings.

    _SequenceIndex              accumulate_minimal_n;

    unsigned int                adjacent_difference_minimal_n;

    _SequenceIndex              count_minimal_n;

    _SequenceIndex              fill_minimal_n;

    double                      find_increasing_factor;

    _SequenceIndex              find_initial_block_size;

    _SequenceIndex              find_maximum_block_size;

    _SequenceIndex              find_sequential_search_size;

    _SequenceIndex              for_each_minimal_n;

    _SequenceIndex              generate_minimal_n;

    _SequenceIndex              max_element_minimal_n;

    _SequenceIndex              merge_minimal_n;

    unsigned int                merge_oversampling;

    _SequenceIndex              min_element_minimal_n;

    _SequenceIndex              multiway_merge_minimal_n;

    int                         multiway_merge_minimal_k;

    unsigned int                multiway_merge_oversampling;

    _SequenceIndex              nth_element_minimal_n;

    _SequenceIndex              partition_chunk_size;

    double                      partition_chunk_share;

    _SequenceIndex              partition_minimal_n;

    _SequenceIndex              partial_sort_minimal_n;

    float                       partial_sum_dilation;

    unsigned int                partial_sum_minimal_n;

    unsigned int                random_shuffle_minimal_n;

    _SequenceIndex              replace_minimal_n;

    _SequenceIndex              set_difference_minimal_n;

    _SequenceIndex              set_intersection_minimal_n;

    _SequenceIndex              set_symmetric_difference_minimal_n;

    _SequenceIndex              set_union_minimal_n;

    _SequenceIndex              sort_minimal_n;

    unsigned int                sort_mwms_oversampling;

    unsigned int                sort_qs_num_samples_preset;

    _SequenceIndex              sort_qsb_base_case_maximal_n;

    _SequenceIndex              transform_minimal_n;

    _SequenceIndex              unique_copy_minimal_n;

    _SequenceIndex              workstealing_chunk_size;

    // Hardware dependent tuning parameters.

    unsigned long long          L1_cache_size;

    unsigned long long          L2_cache_size;

    unsigned int                TLB_size;

    unsigned int                cache_line_size;

    // Statistics.

    _SequenceIndex              qsb_steals;

    _SequenceIndex              search_minimal_n;

    float                       find_scale_factor;

    _GLIBCXX_CONST static const _Settings&
    get() throw();

    static void
    set(_Settings&) throw();

    explicit 
    _Settings() :
            algorithm_strategy(heuristic),
            sort_algorithm(MWMS),
            partial_sum_algorithm(LINEAR),
            multiway_merge_algorithm(LOSER_TREE),
            find_algorithm(CONSTANT_SIZE_BLOCKS),
            sort_splitting(EXACT),
            merge_splitting(EXACT),
            multiway_merge_splitting(EXACT),
            accumulate_minimal_n(1000),
            adjacent_difference_minimal_n(1000),
            count_minimal_n(1000),
            fill_minimal_n(1000),
            find_increasing_factor(2.0),
            find_initial_block_size(256),
            find_maximum_block_size(8192),
            find_sequential_search_size(256),
            for_each_minimal_n(1000),
            generate_minimal_n(1000),
            max_element_minimal_n(1000),
            merge_minimal_n(1000),
            merge_oversampling(10),
            min_element_minimal_n(1000),
            multiway_merge_minimal_n(1000),
            multiway_merge_minimal_k(2), multiway_merge_oversampling(10),
            nth_element_minimal_n(1000),
            partition_chunk_size(1000),
            partition_chunk_share(0.0),
            partition_minimal_n(1000),
            partial_sort_minimal_n(1000),
            partial_sum_dilation(1.0f),
            partial_sum_minimal_n(1000),
            random_shuffle_minimal_n(1000),
            replace_minimal_n(1000),
            set_difference_minimal_n(1000),
            set_intersection_minimal_n(1000),
            set_symmetric_difference_minimal_n(1000),
            set_union_minimal_n(1000),
            sort_minimal_n(1000),
            sort_mwms_oversampling(10),
            sort_qs_num_samples_preset(100),
            sort_qsb_base_case_maximal_n(100),
            transform_minimal_n(1000),
            unique_copy_minimal_n(10000),
            workstealing_chunk_size(100),
            L1_cache_size(16 << 10),
            L2_cache_size(256 << 10),
            TLB_size(128),
            cache_line_size(64),
            qsb_steals(0),
            search_minimal_n(1000),
            find_scale_factor(0.01f)
    { }
  };
}

#endif /* _GLIBCXX_PARALLEL_SETTINGS_H */