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