warp-lang 1.0.1__py3-none-manylinux2014_aarch64.whl → 1.1.0__py3-none-manylinux2014_aarch64.whl

warp/native/range.h

@@ -1,109 +1,109 @@
-#pragma once
-
-namespace wp
-{
-
-// All iterable types should implement 3 methods:
-//
-// T iter_next(iter)       - returns the current value and moves iterator to next state 
-// int iter_cmp(iter)      - returns 0 if finished
-// iter iter_reverse(iter) - return an iterator of the same type representing the reverse order
-//
-// iter_next() should also be registered as a built-in hidden function so that code-gen
-// can call it and generate the appropriate variable storage
-
-// represents a built-in Python range() loop
-struct range_t
-{
-    CUDA_CALLABLE range_t()
-        : start(0),
-          end(0),
-          step(0),
-          i(0)
-    {}
-
-    int start;
-    int end;
-    int step;
-    
-    int i;
-};
-
-CUDA_CALLABLE inline range_t range(int end)
-{
-    range_t r;
-    r.start = 0;
-    r.end = end;
-    r.step = 1;
-    
-    r.i = r.start;
-
-    return r;
-}
-
-CUDA_CALLABLE inline range_t range(int start, int end)
-{
-    range_t r;
-    r.start = start;
-    r.end = end;
-    r.step = 1;
-    
-    r.i = r.start;
-
-    return r;
-}
-
-CUDA_CALLABLE inline range_t range(int start, int end, int step)
-{
-    range_t r;
-    r.start = start;
-    r.end = end;
-    r.step = step;
-    
-    r.i = r.start;
-
-    return r;
-}
-
-
-CUDA_CALLABLE inline void adj_range(int end, int adj_end, range_t& adj_ret) {}
-CUDA_CALLABLE inline void adj_range(int start, int end, int adj_start, int adj_end, range_t& adj_ret) {}
-CUDA_CALLABLE inline void adj_range(int start, int end, int step, int adj_start, int adj_end, int adj_step, range_t& adj_ret) {}
-
-
-CUDA_CALLABLE inline int iter_next(range_t& r)
-{
-    int iter = r.i;
-
-    r.i += r.step;
-    return iter;
-}
-
-CUDA_CALLABLE inline bool iter_cmp(const range_t& r)
-{
-    // implements for-loop comparison to emulate Python range() loops with negative arguments
-    if (r.step == 0)
-        // degenerate case where step == 0
-        return false;
-    if (r.step > 0)
-        // normal case where step > 0
-        return r.i < r.end;
-    else
-        // reverse case where step < 0
-        return r.i > r.end;
-}
-
-CUDA_CALLABLE inline range_t iter_reverse(const range_t& r)
-{
-    // generates a reverse range, equivalent to reversed(range())
-    range_t rev;
-    rev.start = r.end-1;
-    rev.end = r.start-1;
-    rev.step = -r.step;
-
-    rev.i = rev.start;
-    
-    return rev;
-}
-
+#pragma once
+
+namespace wp
+{
+
+// All iterable types should implement 3 methods:
+//
+// T iter_next(iter)       - returns the current value and moves iterator to next state 
+// int iter_cmp(iter)      - returns 0 if finished
+// iter iter_reverse(iter) - return an iterator of the same type representing the reverse order
+//
+// iter_next() should also be registered as a built-in hidden function so that code-gen
+// can call it and generate the appropriate variable storage
+
+// represents a built-in Python range() loop
+struct range_t
+{
+    CUDA_CALLABLE range_t()
+        : start(0),
+          end(0),
+          step(0),
+          i(0)
+    {}
+
+    int start;
+    int end;
+    int step;
+    
+    int i;
+};
+
+CUDA_CALLABLE inline range_t range(int end)
+{
+    range_t r;
+    r.start = 0;
+    r.end = end;
+    r.step = 1;
+    
+    r.i = r.start;
+
+    return r;
+}
+
+CUDA_CALLABLE inline range_t range(int start, int end)
+{
+    range_t r;
+    r.start = start;
+    r.end = end;
+    r.step = 1;
+    
+    r.i = r.start;
+
+    return r;
+}
+
+CUDA_CALLABLE inline range_t range(int start, int end, int step)
+{
+    range_t r;
+    r.start = start;
+    r.end = end;
+    r.step = step;
+    
+    r.i = r.start;
+
+    return r;
+}
+
+
+CUDA_CALLABLE inline void adj_range(int end, int adj_end, range_t& adj_ret) {}
+CUDA_CALLABLE inline void adj_range(int start, int end, int adj_start, int adj_end, range_t& adj_ret) {}
+CUDA_CALLABLE inline void adj_range(int start, int end, int step, int adj_start, int adj_end, int adj_step, range_t& adj_ret) {}
+
+
+CUDA_CALLABLE inline int iter_next(range_t& r)
+{
+    int iter = r.i;
+
+    r.i += r.step;
+    return iter;
+}
+
+CUDA_CALLABLE inline bool iter_cmp(const range_t& r)
+{
+    // implements for-loop comparison to emulate Python range() loops with negative arguments
+    if (r.step == 0)
+        // degenerate case where step == 0
+        return false;
+    if (r.step > 0)
+        // normal case where step > 0
+        return r.i < r.end;
+    else
+        // reverse case where step < 0
+        return r.i > r.end;
+}
+
+CUDA_CALLABLE inline range_t iter_reverse(const range_t& r)
+{
+    // generates a reverse range, equivalent to reversed(range())
+    range_t rev;
+    rev.start = r.end-1;
+    rev.end = r.start-1;
+    rev.step = -r.step;
+
+    rev.i = rev.start;
+    
+    return rev;
+}
+
 } // namespace wp

warp/native/reduce.cpp

@@ -1,157 +1,157 @@
-#include "warp.h"
-
-namespace
-{
-
-// Specialized accumulation functions for common type sizes
-template <int N, typename T> void fixed_len_sum(const T *val, T *sum, int value_size)
-{
-    for (int i = 0; i < N; ++i, ++val, ++sum)
-    {
-        *sum += *val;
-    }
-}
-
-template <typename T> void dyn_len_sum(const T *val, T *sum, int value_size)
-{
-    for (int i = 0; i < value_size; ++i, ++val, ++sum)
-    {
-        *sum += *val;
-    }
-}
-
-template <int N, typename T> void fixed_len_inner(const T *a, const T *b, T *dot, int value_size)
-{
-    for (int i = 0; i < N; ++i, ++a, ++b)
-    {
-        *dot += *a * *b;
-    }
-}
-
-template <typename T> void dyn_len_inner(const T *a, const T *b, T *dot, int value_size)
-{
-    for (int i = 0; i < value_size; ++i, ++a, ++b)
-    {
-        *dot += *a * *b;
-    }
-}
-
-} // namespace
-
-template <typename T>
-void array_inner_host(const T *ptr_a, const T *ptr_b, T *ptr_out, int count, int byte_stride_a, int byte_stride_b,
-                      int type_length)
-{
-    assert((byte_stride_a % sizeof(T)) == 0);
-    assert((byte_stride_b % sizeof(T)) == 0);
-    const int stride_a = byte_stride_a / sizeof(T);
-    const int stride_b = byte_stride_b / sizeof(T);
-
-    void (*inner_func)(const T *, const T *, T *, int);
-    switch (type_length)
-    {
-    case 1:
-        inner_func = fixed_len_inner<1, T>;
-        break;
-    case 2:
-        inner_func = fixed_len_inner<2, T>;
-        break;
-    case 3:
-        inner_func = fixed_len_inner<3, T>;
-        break;
-    case 4:
-        inner_func = fixed_len_inner<4, T>;
-        break;
-    default:
-        inner_func = dyn_len_inner<T>;
-    }
-
-    *ptr_out = 0.0f;
-    for (int i = 0; i < count; ++i)
-    {
-        inner_func(ptr_a + i * stride_a, ptr_b + i * stride_b, ptr_out, type_length);
-    }
-}
-
-template <typename T> void array_sum_host(const T *ptr_a, T *ptr_out, int count, int byte_stride, int type_length)
-{
-    assert((byte_stride % sizeof(T)) == 0);
-    const int stride = byte_stride / sizeof(T);
-
-    void (*accumulate_func)(const T *, T *, int);
-    switch (type_length)
-    {
-    case 1:
-        accumulate_func = fixed_len_sum<1, T>;
-        break;
-    case 2:
-        accumulate_func = fixed_len_sum<2, T>;
-        break;
-    case 3:
-        accumulate_func = fixed_len_sum<3, T>;
-        break;
-    case 4:
-        accumulate_func = fixed_len_sum<4, T>;
-        break;
-    default:
-        accumulate_func = dyn_len_sum<T>;
-    }
-
-    memset(ptr_out, 0, sizeof(T)*type_length);
-    for (int i = 0; i < count; ++i)
-        accumulate_func(ptr_a + i * stride, ptr_out, type_length);
-}
-
-void array_inner_float_host(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
-                            int type_length)
-{
-    const float *ptr_a = (const float *)(a);
-    const float *ptr_b = (const float *)(b);
-    float *ptr_out = (float *)(out);
-
-    array_inner_host(ptr_a, ptr_b, ptr_out, count, byte_stride_a, byte_stride_b, type_length);
-}
-
-void array_inner_double_host(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
-                             int type_length)
-{
-    const double *ptr_a = (const double *)(a);
-    const double *ptr_b = (const double *)(b);
-    double *ptr_out = (double *)(out);
-
-    array_inner_host(ptr_a, ptr_b, ptr_out, count, byte_stride_a, byte_stride_b, type_length);
-}
-
-void array_sum_float_host(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
-{
-    const float *ptr_a = (const float *)(a);
-    float *ptr_out = (float *)(out);
-    array_sum_host(ptr_a, ptr_out, count, byte_stride_a, type_length);
-}
-
-void array_sum_double_host(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
-{
-    const double *ptr_a = (const double *)(a);
-    double *ptr_out = (double *)(out);
-    array_sum_host(ptr_a, ptr_out, count, byte_stride_a, type_length);
-}
-
-#if !WP_ENABLE_CUDA
-void array_inner_float_device(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
-                              int type_length)
-{
-}
-
-void array_inner_double_device(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
-                               int type_length)
-{
-}
-
-void array_sum_float_device(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
-{
-}
-
-void array_sum_double_device(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
-{
-}
+#include "warp.h"
+
+namespace
+{
+
+// Specialized accumulation functions for common type sizes
+template <int N, typename T> void fixed_len_sum(const T *val, T *sum, int value_size)
+{
+    for (int i = 0; i < N; ++i, ++val, ++sum)
+    {
+        *sum += *val;
+    }
+}
+
+template <typename T> void dyn_len_sum(const T *val, T *sum, int value_size)
+{
+    for (int i = 0; i < value_size; ++i, ++val, ++sum)
+    {
+        *sum += *val;
+    }
+}
+
+template <int N, typename T> void fixed_len_inner(const T *a, const T *b, T *dot, int value_size)
+{
+    for (int i = 0; i < N; ++i, ++a, ++b)
+    {
+        *dot += *a * *b;
+    }
+}
+
+template <typename T> void dyn_len_inner(const T *a, const T *b, T *dot, int value_size)
+{
+    for (int i = 0; i < value_size; ++i, ++a, ++b)
+    {
+        *dot += *a * *b;
+    }
+}
+
+} // namespace
+
+template <typename T>
+void array_inner_host(const T *ptr_a, const T *ptr_b, T *ptr_out, int count, int byte_stride_a, int byte_stride_b,
+                      int type_length)
+{
+    assert((byte_stride_a % sizeof(T)) == 0);
+    assert((byte_stride_b % sizeof(T)) == 0);
+    const int stride_a = byte_stride_a / sizeof(T);
+    const int stride_b = byte_stride_b / sizeof(T);
+
+    void (*inner_func)(const T *, const T *, T *, int);
+    switch (type_length)
+    {
+    case 1:
+        inner_func = fixed_len_inner<1, T>;
+        break;
+    case 2:
+        inner_func = fixed_len_inner<2, T>;
+        break;
+    case 3:
+        inner_func = fixed_len_inner<3, T>;
+        break;
+    case 4:
+        inner_func = fixed_len_inner<4, T>;
+        break;
+    default:
+        inner_func = dyn_len_inner<T>;
+    }
+
+    *ptr_out = 0.0f;
+    for (int i = 0; i < count; ++i)
+    {
+        inner_func(ptr_a + i * stride_a, ptr_b + i * stride_b, ptr_out, type_length);
+    }
+}
+
+template <typename T> void array_sum_host(const T *ptr_a, T *ptr_out, int count, int byte_stride, int type_length)
+{
+    assert((byte_stride % sizeof(T)) == 0);
+    const int stride = byte_stride / sizeof(T);
+
+    void (*accumulate_func)(const T *, T *, int);
+    switch (type_length)
+    {
+    case 1:
+        accumulate_func = fixed_len_sum<1, T>;
+        break;
+    case 2:
+        accumulate_func = fixed_len_sum<2, T>;
+        break;
+    case 3:
+        accumulate_func = fixed_len_sum<3, T>;
+        break;
+    case 4:
+        accumulate_func = fixed_len_sum<4, T>;
+        break;
+    default:
+        accumulate_func = dyn_len_sum<T>;
+    }
+
+    memset(ptr_out, 0, sizeof(T)*type_length);
+    for (int i = 0; i < count; ++i)
+        accumulate_func(ptr_a + i * stride, ptr_out, type_length);
+}
+
+void array_inner_float_host(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
+                            int type_length)
+{
+    const float *ptr_a = (const float *)(a);
+    const float *ptr_b = (const float *)(b);
+    float *ptr_out = (float *)(out);
+
+    array_inner_host(ptr_a, ptr_b, ptr_out, count, byte_stride_a, byte_stride_b, type_length);
+}
+
+void array_inner_double_host(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
+                             int type_length)
+{
+    const double *ptr_a = (const double *)(a);
+    const double *ptr_b = (const double *)(b);
+    double *ptr_out = (double *)(out);
+
+    array_inner_host(ptr_a, ptr_b, ptr_out, count, byte_stride_a, byte_stride_b, type_length);
+}
+
+void array_sum_float_host(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
+{
+    const float *ptr_a = (const float *)(a);
+    float *ptr_out = (float *)(out);
+    array_sum_host(ptr_a, ptr_out, count, byte_stride_a, type_length);
+}
+
+void array_sum_double_host(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
+{
+    const double *ptr_a = (const double *)(a);
+    double *ptr_out = (double *)(out);
+    array_sum_host(ptr_a, ptr_out, count, byte_stride_a, type_length);
+}
+
+#if !WP_ENABLE_CUDA
+void array_inner_float_device(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
+                              int type_length)
+{
+}
+
+void array_inner_double_device(uint64_t a, uint64_t b, uint64_t out, int count, int byte_stride_a, int byte_stride_b,
+                               int type_length)
+{
+}
+
+void array_sum_float_device(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
+{
+}
+
+void array_sum_double_device(uint64_t a, uint64_t out, int count, int byte_stride_a, int type_length)
+{
+}
 #endif