base/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_CONFIG_BASE
#define _H_GRB_CONFIG_BASE

#include <cstddef> //size_t
#include <string>

#include <assert.h>
#include <unistd.h> //sysconf

#include <graphblas/backends.hpp>

#ifndef _GRB_NO_STDIO
 #include <iostream> //std::cout
#endif

// if the user did not define _GRB_BACKEND, set it to the default sequential
// implementation
#ifndef _GRB_BACKEND
 #define _GRB_BACKEND reference
#endif


namespace grb {

    namespace config {

        static constexpr grb::Backend default_backend = _GRB_BACKEND;

        class CACHE_LINE_SIZE {

            private:

                static constexpr size_t bytes = 64;

            public:

                static constexpr size_t value() {
                    return bytes;
                }

        };

        class SIMD_SIZE {

            private:

                static constexpr size_t bytes = 64;

            public:

                static constexpr size_t value() {
                    return bytes;
                }

        };

        template< typename T >
        class SIMD_BLOCKSIZE {

            public:

                static constexpr size_t unsafe_value() {
                    return SIMD_SIZE::value() / sizeof( T );
                }

                static constexpr size_t value() {
                    return unsafe_value() > 0 ? unsafe_value() : 1;
                }

        };

        class HARDWARE_THREADS {

            public:

                static long value() {
                    return sysconf( _SC_NPROCESSORS_ONLN );
                }

        };

        class BENCHMARKING {

            public:

                static constexpr size_t inner() {
                    return 1;
                }

                static constexpr size_t outer() {
                    return 10;
                }

        };

        class MEMORY {

            public:

                static constexpr size_t l1_cache_size() {
                    return 32768;
                }

                static constexpr size_t big_memory() {
                    return 31;
                } // 2GB

                static constexpr double random_access_memspeed() {
                    return 147.298;
                }

                static constexpr double stream_memspeed() {
                    return 1931.264;
                }

                static bool report(
                    const std::string prefix, const std::string action,
                    const size_t size, const bool printNewline = true
                ) {
#ifdef _GRB_NO_STDIO
                    (void) prefix;
                    (void) action;
                    (void) size;
                    (void) printNewline;
                    return false;
#else
                    constexpr size_t big =
 #ifdef _DEBUG
                        true;
 #else
                        ( 1ul << big_memory() );
 #endif
                    if( size >= big ) {
                        std::cout << "Info: ";
                        std::cout << prefix << " ";
                        std::cout << action << " ";
                        if( sizeof( size_t ) * 8 > 40 && ( size >> 40 ) > 2 ) {
                            std::cout << ( size >> 40 ) << " TB of memory";
                        } else if( sizeof( size_t ) * 8 > 30 && ( size >> 30 ) > 2 ) {
                            std::cout << ( size >> 30 ) << " GB of memory";
                        } else if( sizeof( size_t ) * 8 > 20 && ( size >> 20 ) > 2 ) {
                            std::cout << ( size >> 20 ) << " MB of memory";
                        } else if( sizeof( size_t ) * 8 > 10 && ( size >> 10 ) > 2 ) {
                            std::cout << ( size >> 10 ) << " kB of memory";
                        } else {
                            std::cout << size << " bytes of memory";
                        }
                        if( printNewline ) {
                            std::cout << ".\n";
                        }
                        return true;
                    }
                    return false;
#endif
                }
        };

        template< grb::Backend backend = default_backend >
        class IMPLEMENTATION {
#ifdef __DOXYGEN__
            public:

                static constexpr ALLOC_MODE defaultAllocMode();

                static constexpr ALLOC_MODE sharedAllocMode();

                static constexpr bool fixedVectorCapacities();
#endif
        };

        typedef unsigned int RowIndexType;

        typedef unsigned int ColIndexType;

        typedef size_t NonzeroIndexType;

        typedef unsigned int VectorIndexType;

    } // namespace config

} // namespace grb

#endif // end _H_GRB_CONFIG_BASE