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''