carray 3.0.4 → 3.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (111) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +205 -0
  3. data/carray.gemspec +1 -1
  4. data/ext/ca_array_pool.c +25 -1
  5. data/ext/ca_axis_dispatch.c +13 -20
  6. data/ext/ca_categorical_iterator.c +27 -20
  7. data/ext/ca_compare.c +4 -4
  8. data/ext/ca_composite_dispatch.c +9 -9
  9. data/ext/ca_kernel_iterator.c +6 -6
  10. data/ext/ca_kernel_iterator.h +112 -83
  11. data/ext/ca_obj_array.c +69 -19
  12. data/ext/ca_obj_bincmp.c +1 -0
  13. data/ext/ca_obj_binop.c +1 -0
  14. data/ext/ca_obj_bitarray.c +5 -1
  15. data/ext/ca_obj_bitfield.c +58 -43
  16. data/ext/ca_obj_byte_swap.c +2 -1
  17. data/ext/ca_obj_const_string.c +15 -3
  18. data/ext/ca_obj_face.c +42 -1
  19. data/ext/ca_obj_field.c +13 -3
  20. data/ext/ca_obj_grid.c +52 -5
  21. data/ext/ca_obj_monop.c +46 -10
  22. data/ext/ca_obj_object.c +64 -12
  23. data/ext/ca_obj_record.c +3 -0
  24. data/ext/ca_obj_reduce.c +4 -0
  25. data/ext/ca_obj_refer.c +18 -9
  26. data/ext/ca_obj_roll.c +26 -6
  27. data/ext/ca_obj_select.c +34 -5
  28. data/ext/ca_obj_shift.c +31 -7
  29. data/ext/ca_obj_stack.c +1 -0
  30. data/ext/ca_obj_stride.c +28 -19
  31. data/ext/ca_obj_string.c +11 -2
  32. data/ext/ca_obj_tile.c +27 -7
  33. data/ext/ca_obj_transpose.c +8 -4
  34. data/ext/ca_obj_triop.c +3 -0
  35. data/ext/ca_obj_window.c +79 -50
  36. data/ext/ca_op_ipower.c +4 -4
  37. data/ext/ca_sort_kernels.h +6 -3
  38. data/ext/carray.h +33 -0
  39. data/ext/carray_access.c +16 -3
  40. data/ext/carray_attribute.c +24 -0
  41. data/ext/carray_cast.c +243 -82
  42. data/ext/carray_cast_func.rb +56 -26
  43. data/ext/carray_conversion.c +2 -2
  44. data/ext/carray_core.c +3 -0
  45. data/ext/carray_count.c +6 -0
  46. data/ext/carray_element.c +9 -4
  47. data/ext/carray_factorize.c +20 -20
  48. data/ext/carray_generate.c +8 -2
  49. data/ext/carray_histogram.c +1 -1
  50. data/ext/carray_index_classifier.c +4 -4
  51. data/ext/carray_internal.h +12 -0
  52. data/ext/carray_kernels_bincmp.c +168 -168
  53. data/ext/carray_kernels_binop.c +900 -900
  54. data/ext/carray_kernels_init.c +4 -4
  55. data/ext/carray_kernels_moncmp.c +96 -96
  56. data/ext/carray_kernels_monop.c +1984 -1984
  57. data/ext/carray_kernels_reduce_aggregate.c +1733 -1733
  58. data/ext/carray_kernels_reduce_cumulative.c +642 -642
  59. data/ext/carray_kernels_reduce_extreme.c +1150 -1150
  60. data/ext/carray_kernels_reduce_variance.c +258 -258
  61. data/ext/carray_kernels_scan.c +128 -128
  62. data/ext/carray_kernels_search.c +340 -340
  63. data/ext/carray_kernels_sort.c +295 -304
  64. data/ext/carray_kernels_triop.c +114 -114
  65. data/ext/carray_key_windows.c +4 -0
  66. data/ext/carray_mask.c +45 -22
  67. data/ext/carray_memory_view.c +2 -2
  68. data/ext/carray_operator.c +5 -5
  69. data/ext/carray_order.c +227 -8
  70. data/ext/carray_random.c +18 -18
  71. data/ext/carray_scatter.c +24 -7
  72. data/ext/carray_slab.c +32 -9
  73. data/ext/carray_sort.c +224 -16
  74. data/ext/carray_sort_kernel.c +5 -7
  75. data/ext/carray_struct.c +35 -43
  76. data/ext/carray_time_text.c +4 -2
  77. data/ext/carray_utils.c +63 -21
  78. data/ext/mkkernel.rb +210 -115
  79. data/ext/version.h +4 -4
  80. data/lib/carray/attribute.rb +17 -4
  81. data/lib/carray/basics.rb +27 -7
  82. data/lib/carray/categorical.rb +30 -16
  83. data/lib/carray/categorical_iterator.rb +6 -6
  84. data/lib/carray/const_string.rb +10 -0
  85. data/lib/carray/data_type_extension.rb +8 -1
  86. data/lib/carray/fixlen_string.rb +41 -2
  87. data/lib/carray/frame/column_verbs.rb +4 -3
  88. data/lib/carray/frame/concat.rb +17 -3
  89. data/lib/carray/frame/frame.rb +6 -7
  90. data/lib/carray/frame/group.rb +100 -13
  91. data/lib/carray/frame/io.rb +3 -1
  92. data/lib/carray/fuse_source.rb +31 -2
  93. data/lib/carray/lazy.rb +35 -0
  94. data/lib/carray/methods/is_in.rb +8 -1
  95. data/lib/carray/segment_iterator.rb +12 -8
  96. data/lib/carray/serialize.rb +19 -2
  97. data/lib/carray/stack.rb +15 -12
  98. data/lib/carray/string.rb +8 -0
  99. data/lib/carray/string_operation_extension.rb +13 -5
  100. data/lib/carray/struct_builder.rb +5 -3
  101. data/lib/carray/time.rb +107 -68
  102. data/yard-stubs/ca_obj_transpose.rb +5 -4
  103. data/yard-stubs/carray_attribute.rb +3 -1
  104. data/yard-stubs/carray_cast.rb +2 -0
  105. data/yard-stubs/carray_conversion.rb +5 -1
  106. data/yard-stubs/carray_element.rb +7 -6
  107. data/yard-stubs/carray_mask.rb +8 -3
  108. data/yard-stubs/carray_math.rb +14 -4
  109. data/yard-stubs/carray_order.rb +100 -4
  110. data/yard-stubs/carray_scatter.rb +7 -5
  111. metadata +1 -1
data/ext/ca_kernel_iterator.h CHANGED
@@ -88,7 +88,14 @@ typedef enum {
88
88
 
89
89
  /* ---- kernel flags ------------------------------------------------------ */
90
90
  #define CA_KERNEL_READ 0x0
91
- #define CA_KERNEL_WRITE 0x1 /* the kernel writes the slab back */
91
+ #define CA_KERNEL_WRITE 0x1 /* the kernel writes the slab back.
92
+ The slab is read first (so a
93
+ kernel may change only some cells),
94
+ and a view that cannot be read --
95
+ CAFake of an object array whose
96
+ cells do not convert -- raises
97
+ there, even for a kernel that
98
+ writes every cell */
92
99
  #define CA_KERNEL_NO_MASK 0x2 /* the kernel cannot take a mask:
93
100
  a masked source is refused */
94
101
  #define CA_KERNEL_CHUNK_HINT 0x4 /* reserved: init refuses it
@@ -803,18 +810,19 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
803
810
  Plain C99 (a do/while block with for-loop declarations). */
804
811
 
805
812
  #define CA_L2_FOR_EACH(T, ptr, n, stride, p, body) do { \
813
+ typedef T __ca_u_T CA_UNALIGNED; \
806
814
  ca_size_t _l2_n = (n); \
807
815
  ca_size_t _l2_s = (stride); \
808
816
  char *_l2_b = (char *)(ptr); \
809
817
  if (_l2_s == sizeof(T)) { \
810
- T *p = (T *)_l2_b; \
818
+ __ca_u_T *p = (__ca_u_T *)_l2_b; \
811
819
  for (ca_size_t _l2_i = 0; _l2_i < _l2_n; _l2_i++) { \
812
820
  body \
813
821
  p++; \
814
822
  } \
815
823
  } else { \
816
824
  for (ca_size_t _l2_i = 0; _l2_i < _l2_n; _l2_i++) { \
817
- T *p = (T *)(_l2_b + _l2_i * _l2_s); \
825
+ __ca_u_T *p = (__ca_u_T *)(_l2_b + _l2_i * _l2_s); \
818
826
  body \
819
827
  } \
820
828
  } \
@@ -1150,6 +1158,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1150
1158
  it dead-code-eliminated; the trailing `(void) idx;` silences any
1151
1159
  set-but-not-used warnings. */
1152
1160
  #define CA_SLAB_REDUCE_T_EX(T, st, p, m, acc, INIT, REDUCE, masked_cnt) do { \
1161
+ typedef T __ca_u_T CA_UNALIGNED; \
1153
1162
  (acc) = (INIT); \
1154
1163
  int8_t __srK = (st).slab_ndim; \
1155
1164
  int8_t __srOuterK = __srK - 1; \
@@ -1194,7 +1203,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1194
1203
  const char *__srQ = (const char *)(p) + __srDoff; \
1195
1204
  if ( (m) == NULL ) { \
1196
1205
  if ( __srContig ) { \
1197
- const T *__srSrc = (const T *) __srQ; \
1206
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1198
1207
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1199
1208
  T v = __srSrc[__sj]; \
1200
1209
  REDUCE; \
@@ -1202,7 +1211,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1202
1211
  } \
1203
1212
  } else { \
1204
1213
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1205
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1214
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1206
1215
  REDUCE; \
1207
1216
  idx++; \
1208
1217
  } \
@@ -1210,7 +1219,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1210
1219
  } else { \
1211
1220
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1212
1221
  if ( __srContig && __srMaskU ) { \
1213
- const T *__srSrc = (const T *) __srQ; \
1222
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1214
1223
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1215
1224
  if ( ! __srMM[__sj] ) { \
1216
1225
  T v = __srSrc[__sj]; \
@@ -1223,7 +1232,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1223
1232
  } else { \
1224
1233
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1225
1234
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1226
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1235
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1227
1236
  REDUCE; \
1228
1237
  } else { \
1229
1238
  (masked_cnt)++; \
@@ -1289,6 +1298,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1289
1298
  * by the compiler when their update is a simple ++ pattern.
1290
1299
  */
1291
1300
  #define CA_SLAB_REDUCE_T_PLUS_EX(T, st, p, m, acc, INIT, REDUCE, masked_cnt) do { \
1301
+ typedef T __ca_u_T CA_UNALIGNED; \
1292
1302
  (acc) = (INIT); \
1293
1303
  int8_t __srK = (st).slab_ndim; \
1294
1304
  int8_t __srOuterK = __srK - 1; \
@@ -1333,7 +1343,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1333
1343
  const char *__srQ = (const char *)(p) + __srDoff; \
1334
1344
  if ( (m) == NULL ) { \
1335
1345
  if ( __srContig ) { \
1336
- const T *__srSrc = (const T *) __srQ; \
1346
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1337
1347
  _CA_SIMD_PLUS(acc) \
1338
1348
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1339
1349
  T v = __srSrc[__sj]; \
@@ -1342,7 +1352,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1342
1352
  } \
1343
1353
  } else { \
1344
1354
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1345
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1355
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1346
1356
  REDUCE; \
1347
1357
  idx++; \
1348
1358
  } \
@@ -1350,7 +1360,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1350
1360
  } else { \
1351
1361
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1352
1362
  if ( __srContig && __srMaskU ) { \
1353
- const T *__srSrc = (const T *) __srQ; \
1363
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1354
1364
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1355
1365
  if ( ! __srMM[__sj] ) { \
1356
1366
  T v = __srSrc[__sj]; \
@@ -1363,7 +1373,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1363
1373
  } else { \
1364
1374
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1365
1375
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1366
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1376
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1367
1377
  REDUCE; \
1368
1378
  } else { \
1369
1379
  (masked_cnt)++; \
@@ -1409,6 +1419,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1409
1419
  * both passes of variance / stddev).
1410
1420
  */
1411
1421
  #define CA_SLAB_REDUCE_SUM8_EX(T, ACC_T, st, p, m, acc, INIT, EXPR, masked_cnt) do { \
1422
+ typedef T __ca_u_T CA_UNALIGNED; \
1412
1423
  (acc) = (INIT); \
1413
1424
  int8_t __srK = (st).slab_ndim; \
1414
1425
  int8_t __srOuterK = __srK - 1; \
@@ -1445,7 +1456,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1445
1456
  const char *__srQ = (const char *)(p) + __srDoff; \
1446
1457
  if ( (m) == NULL ) { \
1447
1458
  if ( __srContig ) { \
1448
- const T *__srSrc = (const T *) __srQ; \
1459
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1449
1460
  ACC_T __a0=(ACC_T)0,__a1=(ACC_T)0,__a2=(ACC_T)0,__a3=(ACC_T)0; \
1450
1461
  ACC_T __a4=(ACC_T)0,__a5=(ACC_T)0,__a6=(ACC_T)0,__a7=(ACC_T)0; \
1451
1462
  ca_size_t __sj = 0, __sN = __srInnerN; \
@@ -1464,14 +1475,14 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1464
1475
  + ((__a4 + __a5) + (__a6 + __a7)); \
1465
1476
  } else { \
1466
1477
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1467
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1478
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1468
1479
  (acc) += EXPR(v); \
1469
1480
  } \
1470
1481
  } \
1471
1482
  } else { \
1472
1483
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1473
1484
  if ( __srContig && __srMaskU ) { \
1474
- const T *__srSrc = (const T *) __srQ; \
1485
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1475
1486
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1476
1487
  if ( ! __srMM[__sj] ) { T v = __srSrc[__sj]; (acc) += EXPR(v); } \
1477
1488
  else { (masked_cnt)++; } \
@@ -1479,7 +1490,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1479
1490
  } else { \
1480
1491
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1481
1492
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1482
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1493
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1483
1494
  (acc) += EXPR(v); \
1484
1495
  } else { (masked_cnt)++; } \
1485
1496
  } \
@@ -1515,6 +1526,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1515
1526
  * single-accumulator case).
1516
1527
  */
1517
1528
  #define CA_SLAB_REDUCE_MIN8_EX(T, ACC_T, st, p, m, acc, INIT, EXPR, masked_cnt) do { \
1529
+ typedef T __ca_u_T CA_UNALIGNED; \
1518
1530
  (acc) = (INIT); \
1519
1531
  int8_t __srK = (st).slab_ndim; \
1520
1532
  int8_t __srOuterK = __srK - 1; \
@@ -1551,7 +1563,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1551
1563
  const char *__srQ = (const char *)(p) + __srDoff; \
1552
1564
  if ( (m) == NULL ) { \
1553
1565
  if ( __srContig ) { \
1554
- const T *__srSrc = (const T *) __srQ; \
1566
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1555
1567
  ACC_T __a0=(acc),__a1=(acc),__a2=(acc),__a3=(acc); \
1556
1568
  ACC_T __a4=(acc),__a5=(acc),__a6=(acc),__a7=(acc); \
1557
1569
  ca_size_t __sj = 0, __sN = __srInnerN; \
@@ -1577,14 +1589,14 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1577
1589
  (acc) = (__c0 < __c1) ? __c0 : __c1; \
1578
1590
  } else { \
1579
1591
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1580
- ACC_T __v = EXPR(*(const T *)(__srQ + __sj * __srInnerS)); \
1592
+ ACC_T __v = EXPR(*(const __ca_u_T *)(__srQ + __sj * __srInnerS)); \
1581
1593
  if (__v < (acc)) (acc) = __v; \
1582
1594
  } \
1583
1595
  } \
1584
1596
  } else { \
1585
1597
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1586
1598
  if ( __srContig && __srMaskU ) { \
1587
- const T *__srSrc = (const T *) __srQ; \
1599
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1588
1600
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1589
1601
  if ( ! __srMM[__sj] ) { \
1590
1602
  ACC_T __v = EXPR(__srSrc[__sj]); \
@@ -1594,7 +1606,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1594
1606
  } else { \
1595
1607
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1596
1608
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1597
- ACC_T __v = EXPR(*(const T *)(__srQ + __sj * __srInnerS)); \
1609
+ ACC_T __v = EXPR(*(const __ca_u_T *)(__srQ + __sj * __srInnerS)); \
1598
1610
  if (__v < (acc)) (acc) = __v; \
1599
1611
  } else { (masked_cnt)++; } \
1600
1612
  } \
@@ -1608,6 +1620,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1608
1620
  } while (0)
1609
1621
 
1610
1622
  #define CA_SLAB_REDUCE_MAX8_EX(T, ACC_T, st, p, m, acc, INIT, EXPR, masked_cnt) do { \
1623
+ typedef T __ca_u_T CA_UNALIGNED; \
1611
1624
  (acc) = (INIT); \
1612
1625
  int8_t __srK = (st).slab_ndim; \
1613
1626
  int8_t __srOuterK = __srK - 1; \
@@ -1644,7 +1657,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1644
1657
  const char *__srQ = (const char *)(p) + __srDoff; \
1645
1658
  if ( (m) == NULL ) { \
1646
1659
  if ( __srContig ) { \
1647
- const T *__srSrc = (const T *) __srQ; \
1660
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1648
1661
  ACC_T __a0=(acc),__a1=(acc),__a2=(acc),__a3=(acc); \
1649
1662
  ACC_T __a4=(acc),__a5=(acc),__a6=(acc),__a7=(acc); \
1650
1663
  ca_size_t __sj = 0, __sN = __srInnerN; \
@@ -1670,14 +1683,14 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1670
1683
  (acc) = (__c0 > __c1) ? __c0 : __c1; \
1671
1684
  } else { \
1672
1685
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1673
- ACC_T __v = EXPR(*(const T *)(__srQ + __sj * __srInnerS)); \
1686
+ ACC_T __v = EXPR(*(const __ca_u_T *)(__srQ + __sj * __srInnerS)); \
1674
1687
  if (__v > (acc)) (acc) = __v; \
1675
1688
  } \
1676
1689
  } \
1677
1690
  } else { \
1678
1691
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1679
1692
  if ( __srContig && __srMaskU ) { \
1680
- const T *__srSrc = (const T *) __srQ; \
1693
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1681
1694
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1682
1695
  if ( ! __srMM[__sj] ) { \
1683
1696
  ACC_T __v = EXPR(__srSrc[__sj]); \
@@ -1687,7 +1700,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1687
1700
  } else { \
1688
1701
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1689
1702
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1690
- ACC_T __v = EXPR(*(const T *)(__srQ + __sj * __srInnerS)); \
1703
+ ACC_T __v = EXPR(*(const __ca_u_T *)(__srQ + __sj * __srInnerS)); \
1691
1704
  if (__v > (acc)) (acc) = __v; \
1692
1705
  } else { (masked_cnt)++; } \
1693
1706
  } \
@@ -1701,6 +1714,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1701
1714
  } while (0)
1702
1715
 
1703
1716
  #define CA_SLAB_REDUCE_STAR8_EX(T, ACC_T, st, p, m, acc, INIT, EXPR, masked_cnt) do { \
1717
+ typedef T __ca_u_T CA_UNALIGNED; \
1704
1718
  (acc) = (INIT); \
1705
1719
  int8_t __srK = (st).slab_ndim; \
1706
1720
  int8_t __srOuterK = __srK - 1; \
@@ -1737,7 +1751,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1737
1751
  const char *__srQ = (const char *)(p) + __srDoff; \
1738
1752
  if ( (m) == NULL ) { \
1739
1753
  if ( __srContig ) { \
1740
- const T *__srSrc = (const T *) __srQ; \
1754
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1741
1755
  ACC_T __a0=(ACC_T)1,__a1=(ACC_T)1,__a2=(ACC_T)1,__a3=(ACC_T)1; \
1742
1756
  ACC_T __a4=(ACC_T)1,__a5=(ACC_T)1,__a6=(ACC_T)1,__a7=(ACC_T)1; \
1743
1757
  ca_size_t __sj = 0, __sN = __srInnerN; \
@@ -1756,14 +1770,14 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1756
1770
  * ((__a4 * __a5) * (__a6 * __a7)); \
1757
1771
  } else { \
1758
1772
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1759
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1773
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1760
1774
  (acc) *= EXPR(v); \
1761
1775
  } \
1762
1776
  } \
1763
1777
  } else { \
1764
1778
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1765
1779
  if ( __srContig && __srMaskU ) { \
1766
- const T *__srSrc = (const T *) __srQ; \
1780
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1767
1781
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1768
1782
  if ( ! __srMM[__sj] ) { T v = __srSrc[__sj]; (acc) *= EXPR(v); } \
1769
1783
  else { (masked_cnt)++; } \
@@ -1771,7 +1785,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1771
1785
  } else { \
1772
1786
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1773
1787
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1774
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1788
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1775
1789
  (acc) *= EXPR(v); \
1776
1790
  } else { (masked_cnt)++; } \
1777
1791
  } \
@@ -1797,6 +1811,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1797
1811
  * (T_LIMIT_HI), matching the pre-SIMD path byte-identically.
1798
1812
  */
1799
1813
  #define CA_SLAB_REDUCE_T_MIN_EX(T, st, p, m, acc, INIT, REDUCE, masked_cnt) do { \
1814
+ typedef T __ca_u_T CA_UNALIGNED; \
1800
1815
  (acc) = (INIT); \
1801
1816
  int8_t __srK = (st).slab_ndim; \
1802
1817
  int8_t __srOuterK = __srK - 1; \
@@ -1841,7 +1856,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1841
1856
  const char *__srQ = (const char *)(p) + __srDoff; \
1842
1857
  if ( (m) == NULL ) { \
1843
1858
  if ( __srContig ) { \
1844
- const T *__srSrc = (const T *) __srQ; \
1859
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1845
1860
  _CA_SIMD_MIN(acc) \
1846
1861
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1847
1862
  T v = __srSrc[__sj]; \
@@ -1850,7 +1865,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1850
1865
  } \
1851
1866
  } else { \
1852
1867
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1853
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1868
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1854
1869
  REDUCE; \
1855
1870
  idx++; \
1856
1871
  } \
@@ -1858,7 +1873,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1858
1873
  } else { \
1859
1874
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1860
1875
  if ( __srContig && __srMaskU ) { \
1861
- const T *__srSrc = (const T *) __srQ; \
1876
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1862
1877
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1863
1878
  if ( ! __srMM[__sj] ) { \
1864
1879
  T v = __srSrc[__sj]; \
@@ -1871,7 +1886,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1871
1886
  } else { \
1872
1887
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1873
1888
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1874
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1889
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1875
1890
  REDUCE; \
1876
1891
  } else { \
1877
1892
  (masked_cnt)++; \
@@ -1890,6 +1905,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1890
1905
 
1891
1906
  /* CA_SLAB_REDUCE_T_MAX_EX (generator-only): same as MIN_EX with `_CA_SIMD_MAX`. */
1892
1907
  #define CA_SLAB_REDUCE_T_MAX_EX(T, st, p, m, acc, INIT, REDUCE, masked_cnt) do { \
1908
+ typedef T __ca_u_T CA_UNALIGNED; \
1893
1909
  (acc) = (INIT); \
1894
1910
  int8_t __srK = (st).slab_ndim; \
1895
1911
  int8_t __srOuterK = __srK - 1; \
@@ -1934,7 +1950,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1934
1950
  const char *__srQ = (const char *)(p) + __srDoff; \
1935
1951
  if ( (m) == NULL ) { \
1936
1952
  if ( __srContig ) { \
1937
- const T *__srSrc = (const T *) __srQ; \
1953
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1938
1954
  _CA_SIMD_MAX(acc) \
1939
1955
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1940
1956
  T v = __srSrc[__sj]; \
@@ -1943,7 +1959,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1943
1959
  } \
1944
1960
  } else { \
1945
1961
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1946
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1962
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1947
1963
  REDUCE; \
1948
1964
  idx++; \
1949
1965
  } \
@@ -1951,7 +1967,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1951
1967
  } else { \
1952
1968
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
1953
1969
  if ( __srContig && __srMaskU ) { \
1954
- const T *__srSrc = (const T *) __srQ; \
1970
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
1955
1971
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1956
1972
  if ( ! __srMM[__sj] ) { \
1957
1973
  T v = __srSrc[__sj]; \
@@ -1964,7 +1980,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1964
1980
  } else { \
1965
1981
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
1966
1982
  if ( ! __srMM[__sj * __srInnerMS] ) { \
1967
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
1983
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
1968
1984
  REDUCE; \
1969
1985
  } else { \
1970
1986
  (masked_cnt)++; \
@@ -1990,6 +2006,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
1990
2006
  * integers).
1991
2007
  */
1992
2008
  #define CA_SLAB_REDUCE_T_STAR_EX(T, st, p, m, acc, INIT, REDUCE, masked_cnt) do { \
2009
+ typedef T __ca_u_T CA_UNALIGNED; \
1993
2010
  (acc) = (INIT); \
1994
2011
  int8_t __srK = (st).slab_ndim; \
1995
2012
  int8_t __srOuterK = __srK - 1; \
@@ -2034,7 +2051,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2034
2051
  const char *__srQ = (const char *)(p) + __srDoff; \
2035
2052
  if ( (m) == NULL ) { \
2036
2053
  if ( __srContig ) { \
2037
- const T *__srSrc = (const T *) __srQ; \
2054
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
2038
2055
  _CA_SIMD_STAR(acc) \
2039
2056
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
2040
2057
  T v = __srSrc[__sj]; \
@@ -2043,7 +2060,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2043
2060
  } \
2044
2061
  } else { \
2045
2062
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
2046
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
2063
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
2047
2064
  REDUCE; \
2048
2065
  idx++; \
2049
2066
  } \
@@ -2051,7 +2068,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2051
2068
  } else { \
2052
2069
  const boolean8_t *__srMM = (const boolean8_t *)(m) + __srMoff; \
2053
2070
  if ( __srContig && __srMaskU ) { \
2054
- const T *__srSrc = (const T *) __srQ; \
2071
+ const __ca_u_T *__srSrc = (const __ca_u_T *) __srQ; \
2055
2072
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
2056
2073
  if ( ! __srMM[__sj] ) { \
2057
2074
  T v = __srSrc[__sj]; \
@@ -2064,7 +2081,7 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2064
2081
  } else { \
2065
2082
  for ( ca_size_t __sj = 0; __sj < __srInnerN; __sj++ ) { \
2066
2083
  if ( ! __srMM[__sj * __srInnerMS] ) { \
2067
- T v = *(const T *)(__srQ + __sj * __srInnerS); \
2084
+ T v = *(const __ca_u_T *)(__srQ + __sj * __srInnerS); \
2068
2085
  REDUCE; \
2069
2086
  } else { \
2070
2087
  (masked_cnt)++; \
@@ -2129,6 +2146,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2129
2146
  The mask `m` applies to the SOURCE only (weights mask is overlaid onto
2130
2147
  source mask by the dispatcher). */
2131
2148
  #define CA_SLAB_REDUCE_ARRAY_T_EX(T, T_W, st, p, m, st_w, p_w, acc, INIT, REDUCE, masked_cnt) do { \
2149
+ typedef T_W __ca_u_T_W CA_UNALIGNED; \
2150
+ typedef T __ca_u_T CA_UNALIGNED; \
2132
2151
  (acc) = (INIT); \
2133
2152
  int8_t __sraK = (st).slab_ndim; \
2134
2153
  int8_t __sraOuterK = __sraK - 1; \
@@ -2182,8 +2201,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2182
2201
  const char *__sraWQ = (const char *)(p_w) + __sraWoff; \
2183
2202
  if ( (m) == NULL ) { \
2184
2203
  if ( __sraContig && __sraContigW ) { \
2185
- const T *__sraSrc = (const T *) __sraQ; \
2186
- const T_W *__sraWgt = (const T_W *) __sraWQ; \
2204
+ const __ca_u_T *__sraSrc = (const __ca_u_T *) __sraQ; \
2205
+ const __ca_u_T_W *__sraWgt = (const __ca_u_T_W *) __sraWQ; \
2187
2206
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2188
2207
  T v = __sraSrc[__saj]; \
2189
2208
  T_W w = __sraWgt[__saj]; \
@@ -2192,8 +2211,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2192
2211
  } \
2193
2212
  } else { \
2194
2213
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2195
- T v = *(const T *)(__sraQ + __saj * __sraInnerS); \
2196
- T_W w = *(const T_W *)(__sraWQ + __saj * __sraInnerWS); \
2214
+ T v = *(const __ca_u_T *)(__sraQ + __saj * __sraInnerS); \
2215
+ T_W w = *(const __ca_u_T_W *)(__sraWQ + __saj * __sraInnerWS); \
2197
2216
  REDUCE; \
2198
2217
  idx++; \
2199
2218
  } \
@@ -2201,8 +2220,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2201
2220
  } else { \
2202
2221
  const boolean8_t *__sraMM = (const boolean8_t *)(m) + __sraMoff; \
2203
2222
  if ( __sraContig && __sraContigW && __sraMaskU ) { \
2204
- const T *__sraSrc = (const T *) __sraQ; \
2205
- const T_W *__sraWgt = (const T_W *) __sraWQ; \
2223
+ const __ca_u_T *__sraSrc = (const __ca_u_T *) __sraQ; \
2224
+ const __ca_u_T_W *__sraWgt = (const __ca_u_T_W *) __sraWQ; \
2206
2225
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2207
2226
  if ( ! __sraMM[__saj] ) { \
2208
2227
  T v = __sraSrc[__saj]; \
@@ -2216,8 +2235,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2216
2235
  } else { \
2217
2236
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2218
2237
  if ( ! __sraMM[__saj * __sraInnerMS] ) { \
2219
- T v = *(const T *)(__sraQ + __saj * __sraInnerS); \
2220
- T_W w = *(const T_W *)(__sraWQ + __saj * __sraInnerWS); \
2238
+ T v = *(const __ca_u_T *)(__sraQ + __saj * __sraInnerS); \
2239
+ T_W w = *(const __ca_u_T_W *)(__sraWQ + __saj * __sraInnerWS); \
2221
2240
  REDUCE; \
2222
2241
  } else { \
2223
2242
  (masked_cnt)++; \
@@ -2249,6 +2268,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2249
2268
  */
2250
2269
  #define CA_SLAB_REDUCE_ARRAY_T_PLUS_EX(T, T_W, st, p, m, st_w, p_w, acc, \
2251
2270
  INIT, REDUCE, masked_cnt) do { \
2271
+ typedef T_W __ca_u_T_W CA_UNALIGNED; \
2272
+ typedef T __ca_u_T CA_UNALIGNED; \
2252
2273
  (acc) = (INIT); \
2253
2274
  int8_t __sraK = (st).slab_ndim; \
2254
2275
  int8_t __sraOuterK = __sraK - 1; \
@@ -2302,8 +2323,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2302
2323
  const char *__sraWQ = (const char *)(p_w) + __sraWoff; \
2303
2324
  if ( (m) == NULL ) { \
2304
2325
  if ( __sraContig && __sraContigW ) { \
2305
- const T *__sraSrc = (const T *) __sraQ; \
2306
- const T_W *__sraWgt = (const T_W *) __sraWQ; \
2326
+ const __ca_u_T *__sraSrc = (const __ca_u_T *) __sraQ; \
2327
+ const __ca_u_T_W *__sraWgt = (const __ca_u_T_W *) __sraWQ; \
2307
2328
  _CA_SIMD_PLUS(acc) \
2308
2329
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2309
2330
  T v = __sraSrc[__saj]; \
@@ -2313,8 +2334,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2313
2334
  } \
2314
2335
  } else { \
2315
2336
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2316
- T v = *(const T *)(__sraQ + __saj * __sraInnerS); \
2317
- T_W w = *(const T_W *)(__sraWQ + __saj * __sraInnerWS); \
2337
+ T v = *(const __ca_u_T *)(__sraQ + __saj * __sraInnerS); \
2338
+ T_W w = *(const __ca_u_T_W *)(__sraWQ + __saj * __sraInnerWS); \
2318
2339
  REDUCE; \
2319
2340
  idx++; \
2320
2341
  } \
@@ -2322,8 +2343,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2322
2343
  } else { \
2323
2344
  const boolean8_t *__sraMM = (const boolean8_t *)(m) + __sraMoff; \
2324
2345
  if ( __sraContig && __sraContigW && __sraMaskU ) { \
2325
- const T *__sraSrc = (const T *) __sraQ; \
2326
- const T_W *__sraWgt = (const T_W *) __sraWQ; \
2346
+ const __ca_u_T *__sraSrc = (const __ca_u_T *) __sraQ; \
2347
+ const __ca_u_T_W *__sraWgt = (const __ca_u_T_W *) __sraWQ; \
2327
2348
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2328
2349
  if ( ! __sraMM[__saj] ) { \
2329
2350
  T v = __sraSrc[__saj]; \
@@ -2337,8 +2358,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2337
2358
  } else { \
2338
2359
  for ( ca_size_t __saj = 0; __saj < __sraInnerN; __saj++ ) { \
2339
2360
  if ( ! __sraMM[__saj * __sraInnerMS] ) { \
2340
- T v = *(const T *)(__sraQ + __saj * __sraInnerS); \
2341
- T_W w = *(const T_W *)(__sraWQ + __saj * __sraInnerWS); \
2361
+ T v = *(const __ca_u_T *)(__sraQ + __saj * __sraInnerS); \
2362
+ T_W w = *(const __ca_u_T_W *)(__sraWQ + __saj * __sraInnerWS); \
2342
2363
  REDUCE; \
2343
2364
  } else { \
2344
2365
  (masked_cnt)++; \
@@ -2378,6 +2399,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2378
2399
  docs/authoring/HOW_TO_WRITE_KERNEL.md. Caller is responsible for invoking
2379
2400
  ca_iter_state_sync_slab on the output state after each slab. */
2380
2401
  #define CA_SLAB_MAP_T(T_IN, T_OUT, st_in, p_in, st_out, p_out, MAP_EXPR) do { \
2402
+ typedef T_OUT __ca_u_T_OUT CA_UNALIGNED; \
2403
+ typedef T_IN __ca_u_T_IN CA_UNALIGNED; \
2381
2404
  int8_t __mK = (st_in).slab_ndim; \
2382
2405
  int8_t __mOuterK = __mK - 1; \
2383
2406
  ca_size_t __mInN = (st_in).slab_dims[__mK - 1]; \
@@ -2398,8 +2421,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2398
2421
  const char *__mQi = (const char *)(p_in) + __mIOff; \
2399
2422
  char *__mQo = (char *) (p_out) + __mOOff; \
2400
2423
  if ( __mIContig && __mOContig ) { \
2401
- const T_IN *__mSi = (const T_IN *) __mQi; \
2402
- T_OUT *__mSo = (T_OUT *) __mQo; \
2424
+ const __ca_u_T_IN *__mSi = (const __ca_u_T_IN *) __mQi; \
2425
+ __ca_u_T_OUT *__mSo = (__ca_u_T_OUT *) __mQo; \
2403
2426
  for ( ca_size_t __mj = 0; __mj < __mInN; __mj++ ) { \
2404
2427
  T_IN v = __mSi[__mj]; \
2405
2428
  T_OUT r; \
@@ -2408,10 +2431,10 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2408
2431
  } \
2409
2432
  } else { \
2410
2433
  for ( ca_size_t __mj = 0; __mj < __mInN; __mj++ ) { \
2411
- T_IN v = *(const T_IN *)(__mQi + __mj * __mInS); \
2434
+ T_IN v = *(const __ca_u_T_IN *)(__mQi + __mj * __mInS); \
2412
2435
  T_OUT r; \
2413
2436
  MAP_EXPR; \
2414
- *(T_OUT *)(__mQo + __mj * __mOutS) = r; \
2437
+ *(__ca_u_T_OUT *)(__mQo + __mj * __mOutS) = r; \
2415
2438
  } \
2416
2439
  } \
2417
2440
  for ( int8_t __mk = __mOuterK - 1; __mk >= 0; __mk-- ) { \
@@ -2460,6 +2483,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2460
2483
  CA_SLAB_REDUCE_T / CA_SLAB_MAP_T. */
2461
2484
  #define CA_SLAB_SCAN_T(T_LOAD, T_OUT, st_in, p_in, m_in, \
2462
2485
  st_out, p_out, INIT, STEP) do { \
2486
+ typedef T_LOAD __ca_u_T_LOAD CA_UNALIGNED; \
2487
+ typedef T_OUT __ca_u_T_OUT CA_UNALIGNED; \
2463
2488
  T_OUT acc = (INIT); \
2464
2489
  int8_t __ssK = (st_in).slab_ndim; \
2465
2490
  int8_t __ssOuterK = __ssK - 1; \
@@ -2485,8 +2510,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2485
2510
  char *__ssQo = (char *) (p_out) + __ssOOff; \
2486
2511
  if ( (m_in) == NULL ) { \
2487
2512
  if ( __ssIContig && __ssOContig ) { \
2488
- const T_LOAD *__ssSi = (const T_LOAD *) __ssQi; \
2489
- T_OUT *__ssSo = (T_OUT *) __ssQo; \
2513
+ const __ca_u_T_LOAD *__ssSi = (const __ca_u_T_LOAD *) __ssQi; \
2514
+ __ca_u_T_OUT *__ssSo = (__ca_u_T_OUT *) __ssQo; \
2490
2515
  for ( ca_size_t __sj = 0; __sj < __ssInnerN; __sj++ ) { \
2491
2516
  T_LOAD v = __ssSi[__sj]; \
2492
2517
  T_OUT r; \
@@ -2495,10 +2520,10 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2495
2520
  } \
2496
2521
  } else { \
2497
2522
  for ( ca_size_t __sj = 0; __sj < __ssInnerN; __sj++ ) { \
2498
- T_LOAD v = *(const T_LOAD *)(__ssQi + __sj * __ssInS); \
2523
+ T_LOAD v = *(const __ca_u_T_LOAD *)(__ssQi + __sj * __ssInS); \
2499
2524
  T_OUT r; \
2500
2525
  STEP; \
2501
- *(T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2526
+ *(__ca_u_T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2502
2527
  } \
2503
2528
  } \
2504
2529
  } else { \
@@ -2507,16 +2532,16 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2507
2532
  T_OUT r; \
2508
2533
  if ( ! __ssMM[__ssMaskU ? __sj : __sj * __ssInMS] ) { \
2509
2534
  T_LOAD v = __ssIContig \
2510
- ? ((const T_LOAD *) __ssQi)[__sj] \
2511
- : *(const T_LOAD *)(__ssQi + __sj * __ssInS); \
2535
+ ? ((const __ca_u_T_LOAD *) __ssQi)[__sj] \
2536
+ : *(const __ca_u_T_LOAD *)(__ssQi + __sj * __ssInS); \
2512
2537
  STEP; \
2513
2538
  } else { \
2514
2539
  r = acc; /* masked: write current running aggregate (legacy parity) */ \
2515
2540
  } \
2516
2541
  if ( __ssOContig ) \
2517
- ((T_OUT *) __ssQo)[__sj] = r; \
2542
+ ((__ca_u_T_OUT *) __ssQo)[__sj] = r; \
2518
2543
  else \
2519
- *(T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2544
+ *(__ca_u_T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2520
2545
  } \
2521
2546
  } \
2522
2547
  for ( int8_t __sk = __ssOuterK - 1; __sk >= 0; __sk-- ) { \
@@ -2553,6 +2578,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2553
2578
  (defensive: falls back to holding the sentinel unmasked). */
2554
2579
  #define CA_SLAB_SCAN_T_GATED(T_LOAD, T_OUT, st_in, p_in, m_in, \
2555
2580
  st_out, p_out, m_out, INIT, STEP) do { \
2581
+ typedef T_LOAD __ca_u_T_LOAD CA_UNALIGNED; \
2582
+ typedef T_OUT __ca_u_T_OUT CA_UNALIGNED; \
2556
2583
  T_OUT acc = (INIT); \
2557
2584
  int8_t __ssK = (st_in).slab_ndim; \
2558
2585
  int8_t __ssOuterK = __ssK - 1; \
@@ -2581,8 +2608,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2581
2608
  int __ssSeen = 0; \
2582
2609
  if ( (m_in) == NULL ) { \
2583
2610
  if ( __ssIContig && __ssOContig ) { \
2584
- const T_LOAD *__ssSi = (const T_LOAD *) __ssQi; \
2585
- T_OUT *__ssSo = (T_OUT *) __ssQo; \
2611
+ const __ca_u_T_LOAD *__ssSi = (const __ca_u_T_LOAD *) __ssQi; \
2612
+ __ca_u_T_OUT *__ssSo = (__ca_u_T_OUT *) __ssQo; \
2586
2613
  for ( ca_size_t __sj = 0; __sj < __ssInnerN; __sj++ ) { \
2587
2614
  T_LOAD v = __ssSi[__sj]; \
2588
2615
  T_OUT r; \
@@ -2591,10 +2618,10 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2591
2618
  } \
2592
2619
  } else { \
2593
2620
  for ( ca_size_t __sj = 0; __sj < __ssInnerN; __sj++ ) { \
2594
- T_LOAD v = *(const T_LOAD *)(__ssQi + __sj * __ssInS); \
2621
+ T_LOAD v = *(const __ca_u_T_LOAD *)(__ssQi + __sj * __ssInS); \
2595
2622
  T_OUT r; \
2596
2623
  STEP; \
2597
- *(T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2624
+ *(__ca_u_T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2598
2625
  } \
2599
2626
  } \
2600
2627
  } else { \
@@ -2603,8 +2630,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2603
2630
  T_OUT r; \
2604
2631
  if ( ! __ssMM[__ssMaskU ? __sj : __sj * __ssInMS] ) { \
2605
2632
  T_LOAD v = __ssIContig \
2606
- ? ((const T_LOAD *) __ssQi)[__sj] \
2607
- : *(const T_LOAD *)(__ssQi + __sj * __ssInS); \
2633
+ ? ((const __ca_u_T_LOAD *) __ssQi)[__sj] \
2634
+ : *(const __ca_u_T_LOAD *)(__ssQi + __sj * __ssInS); \
2608
2635
  STEP; \
2609
2636
  __ssSeen = 1; \
2610
2637
  } else if ( ! __ssSeen && (m_out) != NULL ) { \
@@ -2614,9 +2641,9 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2614
2641
  r = acc; /* masked after first present: hold running extremum */\
2615
2642
  } \
2616
2643
  if ( __ssOContig ) \
2617
- ((T_OUT *) __ssQo)[__sj] = r; \
2644
+ ((__ca_u_T_OUT *) __ssQo)[__sj] = r; \
2618
2645
  else \
2619
- *(T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2646
+ *(__ca_u_T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2620
2647
  } \
2621
2648
  } \
2622
2649
  for ( int8_t __sk = __ssOuterK - 1; __sk >= 0; __sk-- ) { \
@@ -2646,6 +2673,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2646
2673
  "last live value" trail. */
2647
2674
  #define CA_SLAB_SCAN_TA(T_LOAD, T_OUT, T_ACC, st_in, p_in, m_in, \
2648
2675
  st_out, p_out, INIT, STEP) do { \
2676
+ typedef T_LOAD __ca_u_T_LOAD CA_UNALIGNED; \
2677
+ typedef T_OUT __ca_u_T_OUT CA_UNALIGNED; \
2649
2678
  T_ACC acc = (INIT); \
2650
2679
  int8_t __ssK = (st_in).slab_ndim; \
2651
2680
  int8_t __ssOuterK = __ssK - 1; \
@@ -2673,16 +2702,16 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2673
2702
  if ( (m_in) == NULL ) { \
2674
2703
  for ( ca_size_t __sj = 0; __sj < __ssInnerN; __sj++ ) { \
2675
2704
  T_LOAD v = __ssIContig \
2676
- ? ((const T_LOAD *) __ssQi)[__sj] \
2677
- : *(const T_LOAD *)(__ssQi + __sj * __ssInS); \
2705
+ ? ((const __ca_u_T_LOAD *) __ssQi)[__sj] \
2706
+ : *(const __ca_u_T_LOAD *)(__ssQi + __sj * __ssInS); \
2678
2707
  T_OUT r; \
2679
2708
  int first = __ssFirst; \
2680
2709
  STEP; \
2681
2710
  __ssFirst = 0; \
2682
2711
  if ( __ssOContig ) \
2683
- ((T_OUT *) __ssQo)[__sj] = r; \
2712
+ ((__ca_u_T_OUT *) __ssQo)[__sj] = r; \
2684
2713
  else \
2685
- *(T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2714
+ *(__ca_u_T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2686
2715
  } \
2687
2716
  } else { \
2688
2717
  const boolean8_t *__ssMM = (const boolean8_t *)(m_in) + __ssMoff; \
@@ -2690,8 +2719,8 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2690
2719
  T_OUT r; \
2691
2720
  if ( ! __ssMM[__ssMaskU ? __sj : __sj * __ssInMS] ) { \
2692
2721
  T_LOAD v = __ssIContig \
2693
- ? ((const T_LOAD *) __ssQi)[__sj] \
2694
- : *(const T_LOAD *)(__ssQi + __sj * __ssInS); \
2722
+ ? ((const __ca_u_T_LOAD *) __ssQi)[__sj] \
2723
+ : *(const __ca_u_T_LOAD *)(__ssQi + __sj * __ssInS); \
2695
2724
  int first = __ssFirst; \
2696
2725
  STEP; \
2697
2726
  __ssFirst = 0; \
@@ -2699,9 +2728,9 @@ VALUE ca_iter_ensure (int32_t n, ca_iter_state *states,
2699
2728
  r = (T_OUT) 0; /* masked: neutral output for downstream OR */ \
2700
2729
  } \
2701
2730
  if ( __ssOContig ) \
2702
- ((T_OUT *) __ssQo)[__sj] = r; \
2731
+ ((__ca_u_T_OUT *) __ssQo)[__sj] = r; \
2703
2732
  else \
2704
- *(T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2733
+ *(__ca_u_T_OUT *)(__ssQo + __sj * __ssOutS) = r; \
2705
2734
  } \
2706
2735
  } \
2707
2736
  for ( int8_t __sk = __ssOuterK - 1; __sk >= 0; __sk-- ) { \