vertex_list.hpp

Go to the documentation of this file.

#ifndef VERTEX_LIST_HPP
#define VERTEX_LIST_HPP

#include "space_settings.hpp"

// A compressed way to represent a list of vertices.
// Note: using C/python convention so range {0, 2} means vertices 0 and 1
template<class Device>
class VertexList{

    using exspace = typename Device::execution_space; 

    struct IntegerRange{
        int start;
        int end; // Note: using C/python convention so range {0, 2} means vertices 0 and 1

        KOKKOS_INLINE_FUNCTION bool is_in_range(int i) const{
            return (i>=start && i<end);
        }

        KOKKOS_INLINE_FUNCTION int size() const{
            return (end - start);
        }
    };

    View<IntegerRange*,CLayout,Device> ranges;
    View<int*,CLayout,Device> singlets;

    public:

    VertexList(){}

    // Initialize with single range
    VertexList(int start, int end);

    // Initialize with a condition, e.g.:
    //     VertexList<HostType>(grid.nnode, KOKKOS_LAMBDA( const int i){return grid_h.is_in_psi_range(i)});
    template<typename F>
    VertexList(int n, F condition){
        int nranges = 0;
        int nsinglets = 0;
        int istart = 0;
        bool was_in_list = false;
        for(int i=0; i<n+1; i++){
            bool in_list = false;
            if(i<n) in_list = condition(i);

            // Entered new range
            if(in_list && !was_in_list){
                istart = i;
            }

            // Just left range
            if(was_in_list && !in_list){
                if(i == istart+1){
                    nsinglets += 1;
                }else{
                    nranges += 1;
                }
            }
        }

        // Allocate
        ranges = View<IntegerRange*,CLayout,Device>(NoInit("ranges"), nranges);
        singlets = View<int*,CLayout,Device>(NoInit("singlets"), nsinglets);
        
        // Now populate views
        nranges = 0;
        nsinglets = 0;
        istart = 0;
        was_in_list = false;
        for(int i=0; i<n+1; i++){
            bool in_list = false;
            if(i<n) in_list = condition(i);

            // Entered new range
            if(in_list && !was_in_list){
                istart = i;
            }

            // Just left range
            if(was_in_list && !in_list){
                if(i == istart+1){
                    singlets(nsinglets) = istart;
                    nsinglets += 1;
                }else{
                    ranges(nranges) = {istart, i}; // Note: using C/python convention so range {0, 2} means vertices 0 and 1
                    nranges += 1;
                }
            }
        }
    }

    // Initialize the list by passing in the full uncompressed list of vertices.
    VertexList(const View<int*,CLayout,Device>& unordered_full_list, bool one_indexed);

    // Execute a lambda function on the vertex list
    template<typename F>
    void parallel_for(F func) const{
        // Loop through ranges
        for (int is=0; is<ranges.size(); is++){
            Kokkos::parallel_for("vertex_list_parallel_for", Kokkos::RangePolicy<exspace>( ranges(is).start, ranges(is).end), KOKKOS_LAMBDA( const int i){
                func(i);
            });
        }

        // Now through singlets
        auto s = singlets; // To avoid passing class member
        Kokkos::parallel_for("vertex_list_parallel_for2", Kokkos::RangePolicy<exspace>(0, singlets.size()), KOKKOS_LAMBDA( const int i){
            // Map to true index
            func(s(i));
        });

        Kokkos::fence();
    }

    KOKKOS_INLINE_FUNCTION bool is_in_list(int i) const {
        // First check ranges
        for (int is=0; is<ranges.size(); is++){
            if(ranges(is).is_in_range(i)) return true;
        }

        // Otherwise, check singlets
        for(int is=0; is<singlets.size(); is++){
            if(singlets(is)==i) return true;
        }

        return false;
    }

    // Number of vertices
    KOKKOS_INLINE_FUNCTION int size(){
        int n = singlets.size();

        // Add ranges
        for (int is=0; is<ranges.size(); is++){
            n += ranges(is).size();
        }   

        return n;
    }

    template<typename DeviceExSpace, typename F>
    inline void for_all(const std::string label, F lambda_func) const {
        // Loop through ranges
        for (int is=0; is<ranges.size(); is++){
            Kokkos::parallel_for(label, Kokkos::RangePolicy<DeviceExSpace>(ranges(is).start, ranges(is).end), lambda_func);
        }

        // Now through singlets
        auto singlets_c = singlets;
        Kokkos::parallel_for(label, Kokkos::RangePolicy<DeviceExSpace>(0, singlets.size()), KOKKOS_LAMBDA( const int i){
            lambda_func(singlets_c(i)); // Map to true index
        });
    }

    void pack_contiguous(const View<double*, CLayout, HostType>& input, const View<double*, CLayout, HostType>& contiguous) const;

    void unpack_contiguous(const View<double*, CLayout, HostType>& contiguous, const View<double*, CLayout, HostType>& output) const;

    VertexList intersection(const VertexList& list2) const;

    int min() const;

    bool is_contiguous() const;
};

#endif