vertex_list.hpp

Go to the documentation of this file.

#ifndef VERTEX_LIST_HPP
#define VERTEX_LIST_HPP
 
#include "space_settings.hpp"
 
template<typename Device, typename F>
int get_starts_and_ends(int n, F condition, View<bool*, CLayout, HostType>& starts_h, View<bool*, CLayout, HostType>& ends_h){
    View<bool*, CLayout, Device> starts(NoInit("starts"), n);
    View<bool*, CLayout, Device> ends(NoInit("ends"), n);
 
    // First, determine which vertices go on the list
    View<bool*, CLayout, Device> is_in(NoInit("is_in"), n);
    Kokkos::parallel_for("check_condition", Kokkos::RangePolicy<typename Device::execution_space>(0, n), KOKKOS_LAMBDA(const int i){
        is_in(i) = condition(i);
    });
 
    // Next, subtract to get list starts and stops
    int nranges = 0;
    Kokkos::parallel_reduce("check_condition", Kokkos::RangePolicy<typename Device::execution_space>(0, n), KOKKOS_LAMBDA(const int i, int& nranges_l){
        starts(i) = false;
        ends(i) = false;
        if(is_in(i)){
            if(i==n-1){
                ends(i) = true;
                nranges_l++;
            }else{
                if(!is_in(i+1)){ // List just ended
                    ends(i) = true;
                    nranges_l++;
                }
            }
 
            if(i==0){
                 starts(i) = true;
            }else{
                if(!is_in(i-1)){ // List just started
                    starts(i) = true;
                }
            }
        }
    }, nranges);
 
    ends_h = View<bool*, CLayout, HostType>(NoInit("ends"), n);
    starts_h = View<bool*, CLayout, HostType>(NoInit("starts"), n);
    Kokkos::deep_copy(ends_h, ends);
    Kokkos::deep_copy(starts_h, starts);
 
    return nranges;
}
 
// A compressed way to represent a list of vertices.
// Note: using C/python convention so range {0, 2} means vertices 0 and 1
class VertexList{
    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);
        }
    };
    public:
    View<IntegerRange*,CLayout,HostType> ranges;
 
    View<int*,CLayout,DeviceType> mapping;
    bool use_mapping;
 
    public:
 
    void plan(){
        // Start with assumption that we should just use mapping method
        View<int*,CLayout,DeviceType> mapping_l(NoInit("mapping"), size());
    
        // Loop through ranges
        int offset = 0;
        for (int is=0; is<ranges.size(); is++){
            int r_offset = ranges(is).start;
            Kokkos::parallel_for("vertex_list_parallel_for", Kokkos::RangePolicy<ExSpace>( 0, ranges(is).size() ), KOKKOS_LAMBDA( const int i){
                mapping_l(offset + i) = r_offset + i;
            });
            offset += ranges(is).size();
        }
        Kokkos::fence();
        mapping = mapping_l;
        use_mapping = true;
    }
 
    VertexList()
      : ranges("ranges", 0), use_mapping(false)
    {}
 
    // Initialize with single range
    VertexList(int start, int end);
 
    // Initialize with a condition, e.g.:
    //     VertexList(grid.nnode, KOKKOS_LAMBDA( const int i){return grid_h.is_in_psi_range(i)});
    template<typename F>
    VertexList(int n, F condition){
        use_mapping=false;
        View<bool*, CLayout, HostType> starts_h;
        View<bool*, CLayout, HostType> ends_h;
        int nranges = get_starts_and_ends<DeviceType>(n, condition, starts_h, ends_h);
        ranges = View<IntegerRange*,CLayout,HostType>(NoInit("ranges"), nranges);
 
        // Now populate views
        int i_range = 0;
        for(int i=0; i<n; i++){
            if(starts_h(i)){
                ranges(i_range).start = i;
            }
            if(ends_h(i)){
                ranges(i_range).end = i+1; // i is included, therefore the list ends at i+1
                i_range += 1;
            }
        }
    }
 
    // Initialize the list by passing in the full uncompressed list of vertices.
    VertexList(const View<int*,CLayout,HostType>& unordered_full_list, bool one_indexed);
 
    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;
        }
 
        return false;
    }
 
    // Number of vertices
    KOKKOS_INLINE_FUNCTION int size() const{
        int n = 0;
 
        // 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 {
        if(use_mapping && std::is_same<DeviceExSpace, ExSpace>::value){
            // Sparse list - use a mapping instead of a separate parallel_for for each range
            auto mapping_l = mapping;
            Kokkos::parallel_for(label, Kokkos::RangePolicy<DeviceExSpace>(0, mapping.extent(0)), KOKKOS_LAMBDA(const int i){
                lambda_func(mapping_l(i));
            });
        }else{
            // 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);
            }
        }
    }
 
    template<class Device>
    void pack_contiguous(const View<double*, CLayout, Device>& input, const View<double*, CLayout, Device>& contiguous) const;
 
    template<class Device>
    void unpack_contiguous(const View<double*, CLayout, Device>& contiguous, const View<double*, CLayout, Device>& output) const;
 
    VertexList operator&(const VertexList& list2) const;
 
    VertexList& operator|=(const VertexList& rhs); // Custom +=
 
    void shift(int shift_val);
 
    VertexList batch(int first_val, int nvals) const;
 
    void batch(int first_val, int nvals, const View<int*, CLayout, HostType>& view) const;
 
    int min() const;
 
    int max() const;
 
    bool is_contiguous() const;
 
    void print(const std::string& msg) const;
 
    bool is_subset(const VertexList& list2) const;
 
    bool intersects(const VertexList& list2) const;
 
    bool intersects(int start, int end) const;
 
    template<typename T>
    void set_to_value(const T& view, double value) const{
        for_all<typename T::execution_space>("vertex_list_set_to_value", KOKKOS_LAMBDA(const int i){
            view(i) = value;
        });
        Kokkos::fence();
    }
 
    template<typename T, typename F>
    void set_to_value(const T& view, F func) const{
        for_all<typename T::execution_space>("vertex_list_set_to_value", KOKKOS_LAMBDA(const int i){
            view(i) = func(i);
        });
        Kokkos::fence();
    }
 
    // Returns a int view of size nnode_in. Indices in the last are set to 0, while all others are set to 1.
    // This function exists for historical reasons and usage should be replaced with get_view_in_list.
    template<class Device>
    View<int*, CLayout, Device> get_view_int_not_in_list(int nnode_in) const{
        View<int*, CLayout, Device> view(NoInit("is_inside"), nnode_in);
        // Set all values to 1
        Kokkos::deep_copy(view, 1);
 
        // Set values inside list to 0
        for_all<typename Device::execution_space>("set_is_inside", KOKKOS_LAMBDA(const int i){
            view(i) = 0;
        }); 
        Kokkos::fence();
 
        return view;
    }
 
    // Returns a bool view of size nnode_in that is true if the index appears in the list
    template<class Device>
    View<bool*, CLayout, Device> get_view_in_list(const std::string label, int nnode_in) const{
        View<bool*, CLayout, Device> view(NoInit(label), nnode_in);
        Kokkos::deep_copy(view, false);
 
        // Set values inside list to true
        for_all<typename Device::execution_space>("set_view_in_list", KOKKOS_LAMBDA(const int i){
            view(i) = true;
        });
        Kokkos::fence();
 
        return view;
    }
};
 
#endif