reference/config.hpp

Go to the documentation of this file.

 
/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _H_GRB_REFERENCE_CONFIG
#define _H_GRB_REFERENCE_CONFIG
 
#include <graphblas/base/config.hpp>
 
 
namespace grb {
 
    namespace config {
 
        enum ALLOC_MODE {
 
            ALIGNED,
 
            INTERLEAVED
 
        };
 
        std::string toString( const ALLOC_MODE mode );
 
        template< Backend backend >
        class PREFETCHING {
 
            // guard against unintended use
            static_assert( backend == reference || backend == reference_omp,
                "Instantiating for non-reference backend" );
 
            public:
 
                static constexpr bool enabled() {
                    return false;
                }
 
                static constexpr size_t distance() {
                    return 128;
                }
 
        };
 
        template<>
        class IMPLEMENTATION< reference > {
 
            public:
 
                static constexpr ALLOC_MODE defaultAllocMode() {
                    return ALLOC_MODE::ALIGNED;
                }
 
                static constexpr ALLOC_MODE sharedAllocMode() {
                    return ALLOC_MODE::ALIGNED;
                }
 
                static constexpr bool fixedVectorCapacities() {
                    return true;
                }
 
                static constexpr size_t vectorBufferSize( const size_t, const size_t ) {
                    return 0;
                }
 
                static constexpr Backend coordinatesBackend() {
                    return reference;
                }
 
        };
 
        template<>
        class IMPLEMENTATION< reference_omp > {
 
            private:
 
                static constexpr size_t minVectorBufferChunksize() {
                    return CACHE_LINE_SIZE::value();
                }
 
                static constexpr size_t absVectorBufferSize() {
                    return 0;
                }
 
                static constexpr double relVectorBufferSize() {
                    return 1;
                }
 
 
        public:
 
                static constexpr ALLOC_MODE defaultAllocMode() {
                    return ALLOC_MODE::ALIGNED;
                }
 
                static constexpr ALLOC_MODE sharedAllocMode() {
                    // return ALLOC_MODE::ALIGNED; //DBG
                    return ALLOC_MODE::INTERLEAVED;
                }
 
                static constexpr Backend coordinatesBackend() {
                    return reference_omp;
                }
 
                static constexpr bool fixedVectorCapacities() {
                    return true;
                }
 
                static inline size_t vectorBufferSize( const size_t n, const size_t T ) {
                    size_t ret;
                    if( absVectorBufferSize() > 0 ) {
                        (void)n;
                        ret = absVectorBufferSize();
                    } else {
                        constexpr const double factor = relVectorBufferSize();
                        static_assert( factor > 0, "Configuration error" );
                        ret = factor * n;
                    }
                    ret = std::max( ret, T * minVectorBufferChunksize() );
                    ret += T;
                    if( ret % T > 0 ) {
                        ret += T - ( ret % T );
                    }
                    ret = std::max( 2 * T, ret );
                    assert( ret % T == 0 );
                    return ret;
                }
 
        };
 
    } // namespace config
 
} // namespace grb
 
#endif // end ``_H_GRB_REFERENCE_CONFIG''