1104 lines · cpp
1//===-- lib/runtime/reduce.cpp ----------------------------------*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// REDUCE() implementation10 11#include "flang/Runtime/reduce.h"12#include "flang-rt/runtime/descriptor.h"13#include "flang-rt/runtime/reduction-templates.h"14#include "flang-rt/runtime/terminator.h"15#include "flang-rt/runtime/tools.h"16 17namespace Fortran::runtime {18 19template <typename T, bool isByValue> class ReduceAccumulator {20public:21 using Operation = std::conditional_t<isByValue, ValueReductionOperation<T>,22 ReferenceReductionOperation<T>>;23 RT_API_ATTRS ReduceAccumulator(const Descriptor &array, Operation operation,24 const T *identity, Terminator &terminator)25 : array_{array}, operation_{operation}, identity_{identity},26 terminator_{terminator} {}27 RT_API_ATTRS void Reinitialize() { result_.reset(); }28 template <typename A>29 RT_API_ATTRS bool AccumulateAt(const SubscriptValue at[]) {30 const auto *operand{array_.Element<A>(at)};31 if (result_) {32 if constexpr (isByValue) {33 result_ = operation_(*result_, *operand);34 } else {35 result_ = operation_(&*result_, operand);36 }37 } else {38 result_ = *operand;39 }40 return true;41 }42 template <typename A>43 RT_API_ATTRS void GetResult(A *to, int /*zeroBasedDim*/ = -1) {44 if (result_) {45 *to = *result_;46 } else if (identity_) {47 *to = *identity_;48 } else {49 terminator_.Crash("REDUCE() without IDENTITY= has no result");50 }51 }52 53private:54 const Descriptor &array_;55 common::optional<T> result_;56 Operation operation_;57 const T *identity_{nullptr};58 Terminator &terminator_;59};60 61template <typename T, typename OP, bool hasLength>62class BufferedReduceAccumulator {63public:64 RT_API_ATTRS BufferedReduceAccumulator(const Descriptor &array, OP operation,65 const T *identity, Terminator &terminator)66 : array_{array}, operation_{operation}, identity_{identity},67 terminator_{terminator} {}68 RT_API_ATTRS void Reinitialize() { activeTemp_ = -1; }69 template <typename A>70 RT_API_ATTRS bool AccumulateAt(const SubscriptValue at[]) {71 const auto *operand{array_.Element<A>(at)};72 if (activeTemp_ >= 0) {73 if constexpr (hasLength) {74 operation_(&*temp_[1 - activeTemp_], length_, &*temp_[activeTemp_],75 operand, length_, length_);76 } else {77 operation_(&*temp_[1 - activeTemp_], &*temp_[activeTemp_], operand);78 }79 activeTemp_ = 1 - activeTemp_;80 } else {81 activeTemp_ = 0;82 runtime::memcpy(&*temp_[activeTemp_], operand, elementBytes_);83 }84 return true;85 }86 template <typename A>87 RT_API_ATTRS void GetResult(A *to, int /*zeroBasedDim*/ = -1) {88 if (activeTemp_ >= 0) {89 runtime::memcpy(to, &*temp_[activeTemp_], elementBytes_);90 } else if (identity_) {91 runtime::memcpy(to, identity_, elementBytes_);92 } else {93 terminator_.Crash("REDUCE() without IDENTITY= has no result");94 }95 }96 97private:98 const Descriptor &array_;99 OP operation_;100 const T *identity_{nullptr};101 Terminator &terminator_;102 std::size_t elementBytes_{array_.ElementBytes()};103 OwningPtr<T> temp_[2]{SizedNew<T>{terminator_}(elementBytes_),104 SizedNew<T>{terminator_}(elementBytes_)};105 int activeTemp_{-1};106 std::size_t length_{elementBytes_ / sizeof(T)};107};108 109extern "C" {110RT_EXT_API_GROUP_BEGIN111 112std::int8_t RTDEF(ReduceInteger1Ref)(const Descriptor &array,113 ReferenceReductionOperation<std::int8_t> operation, const char *source,114 int line, int dim, const Descriptor *mask, const std::int8_t *identity,115 bool ordered) {116 Terminator terminator{source, line};117 return GetTotalReduction<TypeCategory::Integer, 1>(array, source, line, dim,118 mask,119 ReduceAccumulator<std::int8_t, false>{120 array, operation, identity, terminator},121 "REDUCE");122}123std::int8_t RTDEF(ReduceInteger1Value)(const Descriptor &array,124 ValueReductionOperation<std::int8_t> operation, const char *source,125 int line, int dim, const Descriptor *mask, const std::int8_t *identity,126 bool ordered) {127 Terminator terminator{source, line};128 return GetTotalReduction<TypeCategory::Integer, 1>(array, source, line, dim,129 mask,130 ReduceAccumulator<std::int8_t, true>{131 array, operation, identity, terminator},132 "REDUCE");133}134void RTDEF(ReduceInteger1DimRef)(Descriptor &result, const Descriptor &array,135 ReferenceReductionOperation<std::int8_t> operation, const char *source,136 int line, int dim, const Descriptor *mask, const std::int8_t *identity,137 bool ordered) {138 Terminator terminator{source, line};139 using Accumulator = ReduceAccumulator<std::int8_t, false>;140 Accumulator accumulator{array, operation, identity, terminator};141 PartialReduction<Accumulator, TypeCategory::Integer, 1>(result, array,142 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);143}144void RTDEF(ReduceInteger1DimValue)(Descriptor &result, const Descriptor &array,145 ValueReductionOperation<std::int8_t> operation, const char *source,146 int line, int dim, const Descriptor *mask, const std::int8_t *identity,147 bool ordered) {148 Terminator terminator{source, line};149 using Accumulator = ReduceAccumulator<std::int8_t, true>;150 Accumulator accumulator{array, operation, identity, terminator};151 PartialReduction<Accumulator, TypeCategory::Integer, 1>(result, array,152 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);153}154std::int16_t RTDEF(ReduceInteger2Ref)(const Descriptor &array,155 ReferenceReductionOperation<std::int16_t> operation, const char *source,156 int line, int dim, const Descriptor *mask, const std::int16_t *identity,157 bool ordered) {158 Terminator terminator{source, line};159 return GetTotalReduction<TypeCategory::Integer, 2>(array, source, line, dim,160 mask,161 ReduceAccumulator<std::int16_t, false>{162 array, operation, identity, terminator},163 "REDUCE");164}165std::int16_t RTDEF(ReduceInteger2Value)(const Descriptor &array,166 ValueReductionOperation<std::int16_t> operation, const char *source,167 int line, int dim, const Descriptor *mask, const std::int16_t *identity,168 bool ordered) {169 Terminator terminator{source, line};170 return GetTotalReduction<TypeCategory::Integer, 2>(array, source, line, dim,171 mask,172 ReduceAccumulator<std::int16_t, true>{173 array, operation, identity, terminator},174 "REDUCE");175}176void RTDEF(ReduceInteger2DimRef)(Descriptor &result, const Descriptor &array,177 ReferenceReductionOperation<std::int16_t> operation, const char *source,178 int line, int dim, const Descriptor *mask, const std::int16_t *identity,179 bool ordered) {180 Terminator terminator{source, line};181 using Accumulator = ReduceAccumulator<std::int16_t, false>;182 Accumulator accumulator{array, operation, identity, terminator};183 PartialReduction<Accumulator, TypeCategory::Integer, 2>(result, array,184 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);185}186void RTDEF(ReduceInteger2DimValue)(Descriptor &result, const Descriptor &array,187 ValueReductionOperation<std::int16_t> operation, const char *source,188 int line, int dim, const Descriptor *mask, const std::int16_t *identity,189 bool ordered) {190 Terminator terminator{source, line};191 using Accumulator = ReduceAccumulator<std::int16_t, true>;192 Accumulator accumulator{array, operation, identity, terminator};193 PartialReduction<Accumulator, TypeCategory::Integer, 2>(result, array,194 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);195}196std::int32_t RTDEF(ReduceInteger4Ref)(const Descriptor &array,197 ReferenceReductionOperation<std::int32_t> operation, const char *source,198 int line, int dim, const Descriptor *mask, const std::int32_t *identity,199 bool ordered) {200 Terminator terminator{source, line};201 return GetTotalReduction<TypeCategory::Integer, 4>(array, source, line, dim,202 mask,203 ReduceAccumulator<std::int32_t, false>{204 array, operation, identity, terminator},205 "REDUCE");206}207std::int32_t RTDEF(ReduceInteger4Value)(const Descriptor &array,208 ValueReductionOperation<std::int32_t> operation, const char *source,209 int line, int dim, const Descriptor *mask, const std::int32_t *identity,210 bool ordered) {211 Terminator terminator{source, line};212 return GetTotalReduction<TypeCategory::Integer, 4>(array, source, line, dim,213 mask,214 ReduceAccumulator<std::int32_t, true>{215 array, operation, identity, terminator},216 "REDUCE");217}218void RTDEF(ReduceInteger4DimRef)(Descriptor &result, const Descriptor &array,219 ReferenceReductionOperation<std::int32_t> operation, const char *source,220 int line, int dim, const Descriptor *mask, const std::int32_t *identity,221 bool ordered) {222 Terminator terminator{source, line};223 using Accumulator = ReduceAccumulator<std::int32_t, false>;224 Accumulator accumulator{array, operation, identity, terminator};225 PartialReduction<Accumulator, TypeCategory::Integer, 4>(result, array,226 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);227}228void RTDEF(ReduceInteger4DimValue)(Descriptor &result, const Descriptor &array,229 ValueReductionOperation<std::int32_t> operation, const char *source,230 int line, int dim, const Descriptor *mask, const std::int32_t *identity,231 bool ordered) {232 Terminator terminator{source, line};233 using Accumulator = ReduceAccumulator<std::int32_t, true>;234 Accumulator accumulator{array, operation, identity, terminator};235 PartialReduction<Accumulator, TypeCategory::Integer, 4>(result, array,236 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);237}238std::int64_t RTDEF(ReduceInteger8Ref)(const Descriptor &array,239 ReferenceReductionOperation<std::int64_t> operation, const char *source,240 int line, int dim, const Descriptor *mask, const std::int64_t *identity,241 bool ordered) {242 Terminator terminator{source, line};243 return GetTotalReduction<TypeCategory::Integer, 8>(array, source, line, dim,244 mask,245 ReduceAccumulator<std::int64_t, false>{246 array, operation, identity, terminator},247 "REDUCE");248}249std::int64_t RTDEF(ReduceInteger8Value)(const Descriptor &array,250 ValueReductionOperation<std::int64_t> operation, const char *source,251 int line, int dim, const Descriptor *mask, const std::int64_t *identity,252 bool ordered) {253 Terminator terminator{source, line};254 return GetTotalReduction<TypeCategory::Integer, 8>(array, source, line, dim,255 mask,256 ReduceAccumulator<std::int64_t, true>{257 array, operation, identity, terminator},258 "REDUCE");259}260void RTDEF(ReduceInteger8DimRef)(Descriptor &result, const Descriptor &array,261 ReferenceReductionOperation<std::int64_t> operation, const char *source,262 int line, int dim, const Descriptor *mask, const std::int64_t *identity,263 bool ordered) {264 Terminator terminator{source, line};265 using Accumulator = ReduceAccumulator<std::int64_t, false>;266 Accumulator accumulator{array, operation, identity, terminator};267 PartialReduction<Accumulator, TypeCategory::Integer, 8>(result, array,268 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);269}270void RTDEF(ReduceInteger8DimValue)(Descriptor &result, const Descriptor &array,271 ValueReductionOperation<std::int64_t> operation, const char *source,272 int line, int dim, const Descriptor *mask, const std::int64_t *identity,273 bool ordered) {274 Terminator terminator{source, line};275 using Accumulator = ReduceAccumulator<std::int64_t, true>;276 Accumulator accumulator{array, operation, identity, terminator};277 PartialReduction<Accumulator, TypeCategory::Integer, 8>(result, array,278 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);279}280#ifdef __SIZEOF_INT128__281common::int128_t RTDEF(ReduceInteger16Ref)(const Descriptor &array,282 ReferenceReductionOperation<common::int128_t> operation, const char *source,283 int line, int dim, const Descriptor *mask, const common::int128_t *identity,284 bool ordered) {285 Terminator terminator{source, line};286 return GetTotalReduction<TypeCategory::Integer, 16>(array, source, line, dim,287 mask,288 ReduceAccumulator<common::int128_t, false>{289 array, operation, identity, terminator},290 "REDUCE");291}292common::int128_t RTDEF(ReduceInteger16Value)(const Descriptor &array,293 ValueReductionOperation<common::int128_t> operation, const char *source,294 int line, int dim, const Descriptor *mask, const common::int128_t *identity,295 bool ordered) {296 Terminator terminator{source, line};297 return GetTotalReduction<TypeCategory::Integer, 16>(array, source, line, dim,298 mask,299 ReduceAccumulator<common::int128_t, true>{300 array, operation, identity, terminator},301 "REDUCE");302}303void RTDEF(ReduceInteger16DimRef)(Descriptor &result, const Descriptor &array,304 ReferenceReductionOperation<common::int128_t> operation, const char *source,305 int line, int dim, const Descriptor *mask, const common::int128_t *identity,306 bool ordered) {307 Terminator terminator{source, line};308 using Accumulator = ReduceAccumulator<common::int128_t, false>;309 Accumulator accumulator{array, operation, identity, terminator};310 PartialReduction<Accumulator, TypeCategory::Integer, 16>(result, array,311 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);312}313void RTDEF(ReduceInteger16DimValue)(Descriptor &result, const Descriptor &array,314 ValueReductionOperation<common::int128_t> operation, const char *source,315 int line, int dim, const Descriptor *mask, const common::int128_t *identity,316 bool ordered) {317 Terminator terminator{source, line};318 using Accumulator = ReduceAccumulator<common::int128_t, true>;319 Accumulator accumulator{array, operation, identity, terminator};320 PartialReduction<Accumulator, TypeCategory::Integer, 16>(result, array,321 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);322}323#endif324 325std::uint8_t RTDEF(ReduceUnsigned1Ref)(const Descriptor &array,326 ReferenceReductionOperation<std::uint8_t> operation, const char *source,327 int line, int dim, const Descriptor *mask, const std::uint8_t *identity,328 bool ordered) {329 Terminator terminator{source, line};330 return GetTotalReduction<TypeCategory::Unsigned, 1>(array, source, line, dim,331 mask,332 ReduceAccumulator<std::uint8_t, false>{333 array, operation, identity, terminator},334 "REDUCE");335}336std::uint8_t RTDEF(ReduceUnsigned1Value)(const Descriptor &array,337 ValueReductionOperation<std::uint8_t> operation, const char *source,338 int line, int dim, const Descriptor *mask, const std::uint8_t *identity,339 bool ordered) {340 Terminator terminator{source, line};341 return GetTotalReduction<TypeCategory::Unsigned, 1>(array, source, line, dim,342 mask,343 ReduceAccumulator<std::uint8_t, true>{344 array, operation, identity, terminator},345 "REDUCE");346}347void RTDEF(ReduceUnsigned1DimRef)(Descriptor &result, const Descriptor &array,348 ReferenceReductionOperation<std::uint8_t> operation, const char *source,349 int line, int dim, const Descriptor *mask, const std::uint8_t *identity,350 bool ordered) {351 Terminator terminator{source, line};352 using Accumulator = ReduceAccumulator<std::uint8_t, false>;353 Accumulator accumulator{array, operation, identity, terminator};354 PartialReduction<Accumulator, TypeCategory::Unsigned, 1>(result, array,355 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);356}357void RTDEF(ReduceUnsigned1DimValue)(Descriptor &result, const Descriptor &array,358 ValueReductionOperation<std::uint8_t> operation, const char *source,359 int line, int dim, const Descriptor *mask, const std::uint8_t *identity,360 bool ordered) {361 Terminator terminator{source, line};362 using Accumulator = ReduceAccumulator<std::uint8_t, true>;363 Accumulator accumulator{array, operation, identity, terminator};364 PartialReduction<Accumulator, TypeCategory::Unsigned, 1>(result, array,365 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);366}367std::uint16_t RTDEF(ReduceUnsigned2Ref)(const Descriptor &array,368 ReferenceReductionOperation<std::uint16_t> operation, const char *source,369 int line, int dim, const Descriptor *mask, const std::uint16_t *identity,370 bool ordered) {371 Terminator terminator{source, line};372 return GetTotalReduction<TypeCategory::Unsigned, 2>(array, source, line, dim,373 mask,374 ReduceAccumulator<std::uint16_t, false>{375 array, operation, identity, terminator},376 "REDUCE");377}378std::uint16_t RTDEF(ReduceUnsigned2Value)(const Descriptor &array,379 ValueReductionOperation<std::uint16_t> operation, const char *source,380 int line, int dim, const Descriptor *mask, const std::uint16_t *identity,381 bool ordered) {382 Terminator terminator{source, line};383 return GetTotalReduction<TypeCategory::Unsigned, 2>(array, source, line, dim,384 mask,385 ReduceAccumulator<std::uint16_t, true>{386 array, operation, identity, terminator},387 "REDUCE");388}389void RTDEF(ReduceUnsigned2DimRef)(Descriptor &result, const Descriptor &array,390 ReferenceReductionOperation<std::uint16_t> operation, const char *source,391 int line, int dim, const Descriptor *mask, const std::uint16_t *identity,392 bool ordered) {393 Terminator terminator{source, line};394 using Accumulator = ReduceAccumulator<std::uint16_t, false>;395 Accumulator accumulator{array, operation, identity, terminator};396 PartialReduction<Accumulator, TypeCategory::Unsigned, 2>(result, array,397 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);398}399void RTDEF(ReduceUnsigned2DimValue)(Descriptor &result, const Descriptor &array,400 ValueReductionOperation<std::uint16_t> operation, const char *source,401 int line, int dim, const Descriptor *mask, const std::uint16_t *identity,402 bool ordered) {403 Terminator terminator{source, line};404 using Accumulator = ReduceAccumulator<std::uint16_t, true>;405 Accumulator accumulator{array, operation, identity, terminator};406 PartialReduction<Accumulator, TypeCategory::Unsigned, 2>(result, array,407 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);408}409std::uint32_t RTDEF(ReduceUnsigned4Ref)(const Descriptor &array,410 ReferenceReductionOperation<std::uint32_t> operation, const char *source,411 int line, int dim, const Descriptor *mask, const std::uint32_t *identity,412 bool ordered) {413 Terminator terminator{source, line};414 return GetTotalReduction<TypeCategory::Unsigned, 4>(array, source, line, dim,415 mask,416 ReduceAccumulator<std::uint32_t, false>{417 array, operation, identity, terminator},418 "REDUCE");419}420std::uint32_t RTDEF(ReduceUnsigned4Value)(const Descriptor &array,421 ValueReductionOperation<std::uint32_t> operation, const char *source,422 int line, int dim, const Descriptor *mask, const std::uint32_t *identity,423 bool ordered) {424 Terminator terminator{source, line};425 return GetTotalReduction<TypeCategory::Unsigned, 4>(array, source, line, dim,426 mask,427 ReduceAccumulator<std::uint32_t, true>{428 array, operation, identity, terminator},429 "REDUCE");430}431void RTDEF(ReduceUnsigned4DimRef)(Descriptor &result, const Descriptor &array,432 ReferenceReductionOperation<std::uint32_t> operation, const char *source,433 int line, int dim, const Descriptor *mask, const std::uint32_t *identity,434 bool ordered) {435 Terminator terminator{source, line};436 using Accumulator = ReduceAccumulator<std::uint32_t, false>;437 Accumulator accumulator{array, operation, identity, terminator};438 PartialReduction<Accumulator, TypeCategory::Unsigned, 4>(result, array,439 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);440}441void RTDEF(ReduceUnsigned4DimValue)(Descriptor &result, const Descriptor &array,442 ValueReductionOperation<std::uint32_t> operation, const char *source,443 int line, int dim, const Descriptor *mask, const std::uint32_t *identity,444 bool ordered) {445 Terminator terminator{source, line};446 using Accumulator = ReduceAccumulator<std::uint32_t, true>;447 Accumulator accumulator{array, operation, identity, terminator};448 PartialReduction<Accumulator, TypeCategory::Unsigned, 4>(result, array,449 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);450}451std::uint64_t RTDEF(ReduceUnsigned8Ref)(const Descriptor &array,452 ReferenceReductionOperation<std::uint64_t> operation, const char *source,453 int line, int dim, const Descriptor *mask, const std::uint64_t *identity,454 bool ordered) {455 Terminator terminator{source, line};456 return GetTotalReduction<TypeCategory::Unsigned, 8>(array, source, line, dim,457 mask,458 ReduceAccumulator<std::uint64_t, false>{459 array, operation, identity, terminator},460 "REDUCE");461}462std::uint64_t RTDEF(ReduceUnsigned8Value)(const Descriptor &array,463 ValueReductionOperation<std::uint64_t> operation, const char *source,464 int line, int dim, const Descriptor *mask, const std::uint64_t *identity,465 bool ordered) {466 Terminator terminator{source, line};467 return GetTotalReduction<TypeCategory::Unsigned, 8>(array, source, line, dim,468 mask,469 ReduceAccumulator<std::uint64_t, true>{470 array, operation, identity, terminator},471 "REDUCE");472}473void RTDEF(ReduceUnsigned8DimRef)(Descriptor &result, const Descriptor &array,474 ReferenceReductionOperation<std::uint64_t> operation, const char *source,475 int line, int dim, const Descriptor *mask, const std::uint64_t *identity,476 bool ordered) {477 Terminator terminator{source, line};478 using Accumulator = ReduceAccumulator<std::uint64_t, false>;479 Accumulator accumulator{array, operation, identity, terminator};480 PartialReduction<Accumulator, TypeCategory::Unsigned, 8>(result, array,481 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);482}483void RTDEF(ReduceUnsigned8DimValue)(Descriptor &result, const Descriptor &array,484 ValueReductionOperation<std::uint64_t> operation, const char *source,485 int line, int dim, const Descriptor *mask, const std::uint64_t *identity,486 bool ordered) {487 Terminator terminator{source, line};488 using Accumulator = ReduceAccumulator<std::uint64_t, true>;489 Accumulator accumulator{array, operation, identity, terminator};490 PartialReduction<Accumulator, TypeCategory::Unsigned, 8>(result, array,491 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);492}493#ifdef __SIZEOF_INT128__494common::uint128_t RTDEF(ReduceUnsigned16Ref)(const Descriptor &array,495 ReferenceReductionOperation<common::uint128_t> operation,496 const char *source, int line, int dim, const Descriptor *mask,497 const common::uint128_t *identity, bool ordered) {498 Terminator terminator{source, line};499 return GetTotalReduction<TypeCategory::Unsigned, 16>(array, source, line, dim,500 mask,501 ReduceAccumulator<common::uint128_t, false>{502 array, operation, identity, terminator},503 "REDUCE");504}505common::uint128_t RTDEF(ReduceUnsigned16Value)(const Descriptor &array,506 ValueReductionOperation<common::uint128_t> operation, const char *source,507 int line, int dim, const Descriptor *mask,508 const common::uint128_t *identity, bool ordered) {509 Terminator terminator{source, line};510 return GetTotalReduction<TypeCategory::Unsigned, 16>(array, source, line, dim,511 mask,512 ReduceAccumulator<common::uint128_t, true>{513 array, operation, identity, terminator},514 "REDUCE");515}516void RTDEF(ReduceUnsigned16DimRef)(Descriptor &result, const Descriptor &array,517 ReferenceReductionOperation<common::uint128_t> operation,518 const char *source, int line, int dim, const Descriptor *mask,519 const common::uint128_t *identity, bool ordered) {520 Terminator terminator{source, line};521 using Accumulator = ReduceAccumulator<common::uint128_t, false>;522 Accumulator accumulator{array, operation, identity, terminator};523 PartialReduction<Accumulator, TypeCategory::Unsigned, 16>(result, array,524 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);525}526void RTDEF(ReduceUnsigned16DimValue)(Descriptor &result,527 const Descriptor &array,528 ValueReductionOperation<common::uint128_t> operation, const char *source,529 int line, int dim, const Descriptor *mask,530 const common::uint128_t *identity, bool ordered) {531 Terminator terminator{source, line};532 using Accumulator = ReduceAccumulator<common::uint128_t, true>;533 Accumulator accumulator{array, operation, identity, terminator};534 PartialReduction<Accumulator, TypeCategory::Unsigned, 16>(result, array,535 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);536}537#endif538 539// TODO: real/complex(2 & 3)540float RTDEF(ReduceReal4Ref)(const Descriptor &array,541 ReferenceReductionOperation<float> operation, const char *source, int line,542 int dim, const Descriptor *mask, const float *identity, bool ordered) {543 Terminator terminator{source, line};544 return GetTotalReduction<TypeCategory::Real, 4>(array, source, line, dim,545 mask,546 ReduceAccumulator<float, false>{array, operation, identity, terminator},547 "REDUCE");548}549float RTDEF(ReduceReal4Value)(const Descriptor &array,550 ValueReductionOperation<float> operation, const char *source, int line,551 int dim, const Descriptor *mask, const float *identity, bool ordered) {552 Terminator terminator{source, line};553 return GetTotalReduction<TypeCategory::Real, 4>(array, source, line, dim,554 mask,555 ReduceAccumulator<float, true>{array, operation, identity, terminator},556 "REDUCE");557}558void RTDEF(ReduceReal4DimRef)(Descriptor &result, const Descriptor &array,559 ReferenceReductionOperation<float> operation, const char *source, int line,560 int dim, const Descriptor *mask, const float *identity, bool ordered) {561 Terminator terminator{source, line};562 using Accumulator = ReduceAccumulator<float, false>;563 Accumulator accumulator{array, operation, identity, terminator};564 PartialReduction<Accumulator, TypeCategory::Real, 4>(result, array,565 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);566}567void RTDEF(ReduceReal4DimValue)(Descriptor &result, const Descriptor &array,568 ValueReductionOperation<float> operation, const char *source, int line,569 int dim, const Descriptor *mask, const float *identity, bool ordered) {570 Terminator terminator{source, line};571 using Accumulator = ReduceAccumulator<float, true>;572 Accumulator accumulator{array, operation, identity, terminator};573 PartialReduction<Accumulator, TypeCategory::Real, 4>(result, array,574 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);575}576double RTDEF(ReduceReal8Ref)(const Descriptor &array,577 ReferenceReductionOperation<double> operation, const char *source, int line,578 int dim, const Descriptor *mask, const double *identity, bool ordered) {579 Terminator terminator{source, line};580 return GetTotalReduction<TypeCategory::Real, 8>(array, source, line, dim,581 mask,582 ReduceAccumulator<double, false>{array, operation, identity, terminator},583 "REDUCE");584}585double RTDEF(ReduceReal8Value)(const Descriptor &array,586 ValueReductionOperation<double> operation, const char *source, int line,587 int dim, const Descriptor *mask, const double *identity, bool ordered) {588 Terminator terminator{source, line};589 return GetTotalReduction<TypeCategory::Real, 8>(array, source, line, dim,590 mask,591 ReduceAccumulator<double, true>{array, operation, identity, terminator},592 "REDUCE");593}594void RTDEF(ReduceReal8DimRef)(Descriptor &result, const Descriptor &array,595 ReferenceReductionOperation<double> operation, const char *source, int line,596 int dim, const Descriptor *mask, const double *identity, bool ordered) {597 Terminator terminator{source, line};598 using Accumulator = ReduceAccumulator<double, false>;599 Accumulator accumulator{array, operation, identity, terminator};600 PartialReduction<Accumulator, TypeCategory::Real, 8>(result, array,601 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);602}603void RTDEF(ReduceReal8DimValue)(Descriptor &result, const Descriptor &array,604 ValueReductionOperation<double> operation, const char *source, int line,605 int dim, const Descriptor *mask, const double *identity, bool ordered) {606 Terminator terminator{source, line};607 using Accumulator = ReduceAccumulator<double, true>;608 Accumulator accumulator{array, operation, identity, terminator};609 PartialReduction<Accumulator, TypeCategory::Real, 8>(result, array,610 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);611}612#if HAS_FLOAT80613CppTypeFor<TypeCategory::Real, 10> RTDEF(ReduceReal10Ref)(614 const Descriptor &array,615 ReferenceReductionOperation<CppTypeFor<TypeCategory::Real, 10>> operation,616 const char *source, int line, int dim, const Descriptor *mask,617 const CppTypeFor<TypeCategory::Real, 10> *identity, bool ordered) {618 Terminator terminator{source, line};619 return GetTotalReduction<TypeCategory::Real, 10>(array, source, line, dim,620 mask,621 ReduceAccumulator<CppTypeFor<TypeCategory::Real, 10>, false>{622 array, operation, identity, terminator},623 "REDUCE");624}625CppTypeFor<TypeCategory::Real, 10> RTDEF(ReduceReal10Value)(626 const Descriptor &array,627 ValueReductionOperation<CppTypeFor<TypeCategory::Real, 10>> operation,628 const char *source, int line, int dim, const Descriptor *mask,629 const CppTypeFor<TypeCategory::Real, 10> *identity, bool ordered) {630 Terminator terminator{source, line};631 return GetTotalReduction<TypeCategory::Real, 10>(array, source, line, dim,632 mask,633 ReduceAccumulator<CppTypeFor<TypeCategory::Real, 10>, true>{634 array, operation, identity, terminator},635 "REDUCE");636}637void RTDEF(ReduceReal10DimRef)(Descriptor &result, const Descriptor &array,638 ReferenceReductionOperation<CppTypeFor<TypeCategory::Real, 10>> operation,639 const char *source, int line, int dim, const Descriptor *mask,640 const CppTypeFor<TypeCategory::Real, 10> *identity, bool ordered) {641 Terminator terminator{source, line};642 using Accumulator =643 ReduceAccumulator<CppTypeFor<TypeCategory::Real, 10>, false>;644 Accumulator accumulator{array, operation, identity, terminator};645 PartialReduction<Accumulator, TypeCategory::Real, 10>(result, array,646 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);647}648void RTDEF(ReduceReal10DimValue)(Descriptor &result, const Descriptor &array,649 ValueReductionOperation<CppTypeFor<TypeCategory::Real, 10>> operation,650 const char *source, int line, int dim, const Descriptor *mask,651 const CppTypeFor<TypeCategory::Real, 10> *identity, bool ordered) {652 Terminator terminator{source, line};653 using Accumulator =654 ReduceAccumulator<CppTypeFor<TypeCategory::Real, 10>, true>;655 Accumulator accumulator{array, operation, identity, terminator};656 PartialReduction<Accumulator, TypeCategory::Real, 10>(result, array,657 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);658}659#endif660#if HAS_LDBL128 || HAS_FLOAT128661CppFloat128Type RTDEF(ReduceReal16Ref)(const Descriptor &array,662 ReferenceReductionOperation<CppFloat128Type> operation, const char *source,663 int line, int dim, const Descriptor *mask, const CppFloat128Type *identity,664 bool ordered) {665 Terminator terminator{source, line};666 return GetTotalReduction<TypeCategory::Real, 16>(array, source, line, dim,667 mask,668 ReduceAccumulator<CppFloat128Type, false>{669 array, operation, identity, terminator},670 "REDUCE");671}672CppFloat128Type RTDEF(ReduceReal16Value)(const Descriptor &array,673 ValueReductionOperation<CppFloat128Type> operation, const char *source,674 int line, int dim, const Descriptor *mask, const CppFloat128Type *identity,675 bool ordered) {676 Terminator terminator{source, line};677 return GetTotalReduction<TypeCategory::Real, 16>(array, source, line, dim,678 mask,679 ReduceAccumulator<CppFloat128Type, true>{680 array, operation, identity, terminator},681 "REDUCE");682}683void RTDEF(ReduceReal16DimRef)(Descriptor &result, const Descriptor &array,684 ReferenceReductionOperation<CppFloat128Type> operation, const char *source,685 int line, int dim, const Descriptor *mask, const CppFloat128Type *identity,686 bool ordered) {687 Terminator terminator{source, line};688 using Accumulator = ReduceAccumulator<CppFloat128Type, false>;689 Accumulator accumulator{array, operation, identity, terminator};690 PartialReduction<Accumulator, TypeCategory::Real, 16>(result, array,691 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);692}693void RTDEF(ReduceReal16DimValue)(Descriptor &result, const Descriptor &array,694 ValueReductionOperation<CppFloat128Type> operation, const char *source,695 int line, int dim, const Descriptor *mask, const CppFloat128Type *identity,696 bool ordered) {697 Terminator terminator{source, line};698 using Accumulator = ReduceAccumulator<CppFloat128Type, true>;699 Accumulator accumulator{array, operation, identity, terminator};700 PartialReduction<Accumulator, TypeCategory::Real, 16>(result, array,701 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);702}703#endif704 705void RTDEF(CppReduceComplex4Ref)(CppTypeFor<TypeCategory::Complex, 4> &result,706 const Descriptor &array,707 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 4>> operation,708 const char *source, int line, int dim, const Descriptor *mask,709 const CppTypeFor<TypeCategory::Complex, 4> *identity, bool ordered) {710 Terminator terminator{source, line};711 result = GetTotalReduction<TypeCategory::Complex, 4>(array, source, line, dim,712 mask,713 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 4>, false>{714 array, operation, identity, terminator},715 "REDUCE");716}717void RTDEF(CppReduceComplex4Value)(CppTypeFor<TypeCategory::Complex, 4> &result,718 const Descriptor &array,719 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 4>> operation,720 const char *source, int line, int dim, const Descriptor *mask,721 const CppTypeFor<TypeCategory::Complex, 4> *identity, bool ordered) {722 Terminator terminator{source, line};723 result = GetTotalReduction<TypeCategory::Complex, 4>(array, source, line, dim,724 mask,725 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 4>, true>{726 array, operation, identity, terminator},727 "REDUCE");728}729void RTDEF(CppReduceComplex4DimRef)(Descriptor &result, const Descriptor &array,730 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 4>> operation,731 const char *source, int line, int dim, const Descriptor *mask,732 const CppTypeFor<TypeCategory::Complex, 4> *identity, bool ordered) {733 Terminator terminator{source, line};734 using Accumulator =735 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 4>, false>;736 Accumulator accumulator{array, operation, identity, terminator};737 PartialReduction<Accumulator, TypeCategory::Complex, 4>(result, array,738 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);739}740void RTDEF(CppReduceComplex4DimValue)(Descriptor &result,741 const Descriptor &array,742 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 4>> operation,743 const char *source, int line, int dim, const Descriptor *mask,744 const CppTypeFor<TypeCategory::Complex, 4> *identity, bool ordered) {745 Terminator terminator{source, line};746 using Accumulator =747 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 4>, true>;748 Accumulator accumulator{array, operation, identity, terminator};749 PartialReduction<Accumulator, TypeCategory::Complex, 4>(result, array,750 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);751}752void RTDEF(CppReduceComplex8Ref)(CppTypeFor<TypeCategory::Complex, 8> &result,753 const Descriptor &array,754 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 8>> operation,755 const char *source, int line, int dim, const Descriptor *mask,756 const CppTypeFor<TypeCategory::Complex, 8> *identity, bool ordered) {757 Terminator terminator{source, line};758 result = GetTotalReduction<TypeCategory::Complex, 8>(array, source, line, dim,759 mask,760 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 8>, false>{761 array, operation, identity, terminator},762 "REDUCE");763}764void RTDEF(CppReduceComplex8Value)(CppTypeFor<TypeCategory::Complex, 8> &result,765 const Descriptor &array,766 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 8>> operation,767 const char *source, int line, int dim, const Descriptor *mask,768 const CppTypeFor<TypeCategory::Complex, 8> *identity, bool ordered) {769 Terminator terminator{source, line};770 result = GetTotalReduction<TypeCategory::Complex, 8>(array, source, line, dim,771 mask,772 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 8>, true>{773 array, operation, identity, terminator},774 "REDUCE");775}776void RTDEF(CppReduceComplex8DimRef)(Descriptor &result, const Descriptor &array,777 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 8>> operation,778 const char *source, int line, int dim, const Descriptor *mask,779 const CppTypeFor<TypeCategory::Complex, 8> *identity, bool ordered) {780 Terminator terminator{source, line};781 using Accumulator =782 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 8>, false>;783 Accumulator accumulator{array, operation, identity, terminator};784 PartialReduction<Accumulator, TypeCategory::Complex, 8>(result, array,785 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);786}787void RTDEF(CppReduceComplex8DimValue)(Descriptor &result,788 const Descriptor &array,789 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 8>> operation,790 const char *source, int line, int dim, const Descriptor *mask,791 const CppTypeFor<TypeCategory::Complex, 8> *identity, bool ordered) {792 Terminator terminator{source, line};793 using Accumulator =794 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 8>, true>;795 Accumulator accumulator{array, operation, identity, terminator};796 PartialReduction<Accumulator, TypeCategory::Complex, 8>(result, array,797 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);798}799#if HAS_FLOAT80800void RTDEF(CppReduceComplex10Ref)(CppTypeFor<TypeCategory::Complex, 10> &result,801 const Descriptor &array,802 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 10>>803 operation,804 const char *source, int line, int dim, const Descriptor *mask,805 const CppTypeFor<TypeCategory::Complex, 10> *identity, bool ordered) {806 Terminator terminator{source, line};807 result = GetTotalReduction<TypeCategory::Complex, 10>(array, source, line,808 dim, mask,809 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 10>, false>{810 array, operation, identity, terminator},811 "REDUCE");812}813void RTDEF(CppReduceComplex10Value)(814 CppTypeFor<TypeCategory::Complex, 10> &result, const Descriptor &array,815 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 10>> operation,816 const char *source, int line, int dim, const Descriptor *mask,817 const CppTypeFor<TypeCategory::Complex, 10> *identity, bool ordered) {818 Terminator terminator{source, line};819 result = GetTotalReduction<TypeCategory::Complex, 10>(array, source, line,820 dim, mask,821 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 10>, true>{822 array, operation, identity, terminator},823 "REDUCE");824}825void RTDEF(CppReduceComplex10DimRef)(Descriptor &result,826 const Descriptor &array,827 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 10>>828 operation,829 const char *source, int line, int dim, const Descriptor *mask,830 const CppTypeFor<TypeCategory::Complex, 10> *identity, bool ordered) {831 Terminator terminator{source, line};832 using Accumulator =833 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 10>, false>;834 Accumulator accumulator{array, operation, identity, terminator};835 PartialReduction<Accumulator, TypeCategory::Complex, 10>(result, array,836 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);837}838void RTDEF(CppReduceComplex10DimValue)(Descriptor &result,839 const Descriptor &array,840 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 10>> operation,841 const char *source, int line, int dim, const Descriptor *mask,842 const CppTypeFor<TypeCategory::Complex, 10> *identity, bool ordered) {843 Terminator terminator{source, line};844 using Accumulator =845 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 10>, true>;846 Accumulator accumulator{array, operation, identity, terminator};847 PartialReduction<Accumulator, TypeCategory::Complex, 10>(result, array,848 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);849}850#endif851#if HAS_LDBL128 || HAS_FLOAT128852void RTDEF(CppReduceComplex16Ref)(CppTypeFor<TypeCategory::Complex, 16> &result,853 const Descriptor &array,854 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 16>>855 operation,856 const char *source, int line, int dim, const Descriptor *mask,857 const CppTypeFor<TypeCategory::Complex, 16> *identity, bool ordered) {858 Terminator terminator{source, line};859 result = GetTotalReduction<TypeCategory::Complex, 16>(array, source, line,860 dim, mask,861 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 16>, false>{862 array, operation, identity, terminator},863 "REDUCE");864}865void RTDEF(CppReduceComplex16Value)(866 CppTypeFor<TypeCategory::Complex, 16> &result, const Descriptor &array,867 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 16>> operation,868 const char *source, int line, int dim, const Descriptor *mask,869 const CppTypeFor<TypeCategory::Complex, 16> *identity, bool ordered) {870 Terminator terminator{source, line};871 result = GetTotalReduction<TypeCategory::Complex, 16>(array, source, line,872 dim, mask,873 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 16>, true>{874 array, operation, identity, terminator},875 "REDUCE");876}877void RTDEF(CppReduceComplex16DimRef)(Descriptor &result,878 const Descriptor &array,879 ReferenceReductionOperation<CppTypeFor<TypeCategory::Complex, 16>>880 operation,881 const char *source, int line, int dim, const Descriptor *mask,882 const CppTypeFor<TypeCategory::Complex, 16> *identity, bool ordered) {883 Terminator terminator{source, line};884 using Accumulator =885 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 16>, false>;886 Accumulator accumulator{array, operation, identity, terminator};887 PartialReduction<Accumulator, TypeCategory::Complex, 16>(result, array,888 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);889}890void RTDEF(CppReduceComplex16DimValue)(Descriptor &result,891 const Descriptor &array,892 ValueReductionOperation<CppTypeFor<TypeCategory::Complex, 16>> operation,893 const char *source, int line, int dim, const Descriptor *mask,894 const CppTypeFor<TypeCategory::Complex, 16> *identity, bool ordered) {895 Terminator terminator{source, line};896 using Accumulator =897 ReduceAccumulator<CppTypeFor<TypeCategory::Complex, 16>, true>;898 Accumulator accumulator{array, operation, identity, terminator};899 PartialReduction<Accumulator, TypeCategory::Complex, 16>(result, array,900 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);901}902#endif903 904bool RTDEF(ReduceLogical1Ref)(const Descriptor &array,905 ReferenceReductionOperation<std::int8_t> operation, const char *source,906 int line, int dim, const Descriptor *mask, const std::int8_t *identity,907 bool ordered) {908 return RTNAME(ReduceInteger1Ref)(909 array, operation, source, line, dim, mask, identity, ordered) != 0;910}911bool RTDEF(ReduceLogical1Value)(const Descriptor &array,912 ValueReductionOperation<std::int8_t> operation, const char *source,913 int line, int dim, const Descriptor *mask, const std::int8_t *identity,914 bool ordered) {915 return RTNAME(ReduceInteger1Value)(916 array, operation, source, line, dim, mask, identity, ordered) != 0;917}918void RTDEF(ReduceLogical1DimRef)(Descriptor &result, const Descriptor &array,919 ReferenceReductionOperation<std::int8_t> operation, const char *source,920 int line, int dim, const Descriptor *mask, const std::int8_t *identity,921 bool ordered) {922 RTNAME(ReduceInteger1DimRef)923 (result, array, operation, source, line, dim, mask, identity, ordered);924}925void RTDEF(ReduceLogical1DimValue)(Descriptor &result, const Descriptor &array,926 ValueReductionOperation<std::int8_t> operation, const char *source,927 int line, int dim, const Descriptor *mask, const std::int8_t *identity,928 bool ordered) {929 RTNAME(ReduceInteger1DimValue)930 (result, array, operation, source, line, dim, mask, identity, ordered);931}932bool RTDEF(ReduceLogical2Ref)(const Descriptor &array,933 ReferenceReductionOperation<std::int16_t> operation, const char *source,934 int line, int dim, const Descriptor *mask, const std::int16_t *identity,935 bool ordered) {936 return RTNAME(ReduceInteger2Ref)(937 array, operation, source, line, dim, mask, identity, ordered) != 0;938}939bool RTDEF(ReduceLogical2Value)(const Descriptor &array,940 ValueReductionOperation<std::int16_t> operation, const char *source,941 int line, int dim, const Descriptor *mask, const std::int16_t *identity,942 bool ordered) {943 return RTNAME(ReduceInteger2Value)(944 array, operation, source, line, dim, mask, identity, ordered) != 0;945}946void RTDEF(ReduceLogical2DimRef)(Descriptor &result, const Descriptor &array,947 ReferenceReductionOperation<std::int16_t> operation, const char *source,948 int line, int dim, const Descriptor *mask, const std::int16_t *identity,949 bool ordered) {950 RTNAME(ReduceInteger2DimRef)951 (result, array, operation, source, line, dim, mask, identity, ordered);952}953void RTDEF(ReduceLogical2DimValue)(Descriptor &result, const Descriptor &array,954 ValueReductionOperation<std::int16_t> operation, const char *source,955 int line, int dim, const Descriptor *mask, const std::int16_t *identity,956 bool ordered) {957 RTNAME(ReduceInteger2DimValue)958 (result, array, operation, source, line, dim, mask, identity, ordered);959}960bool RTDEF(ReduceLogical4Ref)(const Descriptor &array,961 ReferenceReductionOperation<std::int32_t> operation, const char *source,962 int line, int dim, const Descriptor *mask, const std::int32_t *identity,963 bool ordered) {964 return RTNAME(ReduceInteger4Ref)(965 array, operation, source, line, dim, mask, identity, ordered) != 0;966}967bool RTDEF(ReduceLogical4Value)(const Descriptor &array,968 ValueReductionOperation<std::int32_t> operation, const char *source,969 int line, int dim, const Descriptor *mask, const std::int32_t *identity,970 bool ordered) {971 return RTNAME(ReduceInteger4Value)(972 array, operation, source, line, dim, mask, identity, ordered) != 0;973}974void RTDEF(ReduceLogical4DimRef)(Descriptor &result, const Descriptor &array,975 ReferenceReductionOperation<std::int32_t> operation, const char *source,976 int line, int dim, const Descriptor *mask, const std::int32_t *identity,977 bool ordered) {978 RTNAME(ReduceInteger4DimRef)979 (result, array, operation, source, line, dim, mask, identity, ordered);980}981void RTDEF(ReduceLogical4DimValue)(Descriptor &result, const Descriptor &array,982 ValueReductionOperation<std::int32_t> operation, const char *source,983 int line, int dim, const Descriptor *mask, const std::int32_t *identity,984 bool ordered) {985 RTNAME(ReduceInteger4DimValue)986 (result, array, operation, source, line, dim, mask, identity, ordered);987}988bool RTDEF(ReduceLogical8Ref)(const Descriptor &array,989 ReferenceReductionOperation<std::int64_t> operation, const char *source,990 int line, int dim, const Descriptor *mask, const std::int64_t *identity,991 bool ordered) {992 return RTNAME(ReduceInteger8Ref)(993 array, operation, source, line, dim, mask, identity, ordered) != 0;994}995bool RTDEF(ReduceLogical8Value)(const Descriptor &array,996 ValueReductionOperation<std::int64_t> operation, const char *source,997 int line, int dim, const Descriptor *mask, const std::int64_t *identity,998 bool ordered) {999 return RTNAME(ReduceInteger8Value)(1000 array, operation, source, line, dim, mask, identity, ordered) != 0;1001}1002void RTDEF(ReduceLogical8DimRef)(Descriptor &result, const Descriptor &array,1003 ReferenceReductionOperation<std::int64_t> operation, const char *source,1004 int line, int dim, const Descriptor *mask, const std::int64_t *identity,1005 bool ordered) {1006 RTNAME(ReduceInteger8DimRef)1007 (result, array, operation, source, line, dim, mask, identity, ordered);1008}1009void RTDEF(ReduceLogical8DimValue)(Descriptor &result, const Descriptor &array,1010 ValueReductionOperation<std::int64_t> operation, const char *source,1011 int line, int dim, const Descriptor *mask, const std::int64_t *identity,1012 bool ordered) {1013 RTNAME(ReduceInteger8DimValue)1014 (result, array, operation, source, line, dim, mask, identity, ordered);1015}1016 1017void RTDEF(ReduceChar1)(char *result, const Descriptor &array,1018 ReductionCharOperation<char> operation, const char *source, int line,1019 int dim, const Descriptor *mask, const char *identity, bool ordered) {1020 Terminator terminator{source, line};1021 BufferedReduceAccumulator<char, ReductionCharOperation<char>,1022 /*hasLength=*/true>1023 accumulator{array, operation, identity, terminator};1024 DoTotalReduction<char>(array, dim, mask, accumulator, "REDUCE", terminator);1025 accumulator.GetResult(result);1026}1027void RTDEF(ReduceCharacter1Dim)(Descriptor &result, const Descriptor &array,1028 ReductionCharOperation<char> operation, const char *source, int line,1029 int dim, const Descriptor *mask, const char *identity, bool ordered) {1030 Terminator terminator{source, line};1031 using Accumulator = BufferedReduceAccumulator<char,1032 ReductionCharOperation<char>, /*hasLength=*/true>;1033 Accumulator accumulator{array, operation, identity, terminator};1034 PartialReduction<Accumulator, TypeCategory::Character, 1>(result, array,1035 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);1036}1037void RTDEF(ReduceChar2)(char16_t *result, const Descriptor &array,1038 ReductionCharOperation<char16_t> operation, const char *source, int line,1039 int dim, const Descriptor *mask, const char16_t *identity, bool ordered) {1040 Terminator terminator{source, line};1041 BufferedReduceAccumulator<char16_t, ReductionCharOperation<char16_t>,1042 /*hasLength=*/true>1043 accumulator{array, operation, identity, terminator};1044 DoTotalReduction<char16_t>(1045 array, dim, mask, accumulator, "REDUCE", terminator);1046 accumulator.GetResult(result);1047}1048void RTDEF(ReduceCharacter2Dim)(Descriptor &result, const Descriptor &array,1049 ReductionCharOperation<char16_t> operation, const char *source, int line,1050 int dim, const Descriptor *mask, const char16_t *identity, bool ordered) {1051 Terminator terminator{source, line};1052 using Accumulator = BufferedReduceAccumulator<char16_t,1053 ReductionCharOperation<char16_t>, /*hasLength=*/true>;1054 Accumulator accumulator{array, operation, identity, terminator};1055 PartialReduction<Accumulator, TypeCategory::Character, 2>(result, array,1056 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);1057}1058void RTDEF(ReduceChar4)(char32_t *result, const Descriptor &array,1059 ReductionCharOperation<char32_t> operation, const char *source, int line,1060 int dim, const Descriptor *mask, const char32_t *identity, bool ordered) {1061 Terminator terminator{source, line};1062 BufferedReduceAccumulator<char32_t, ReductionCharOperation<char32_t>,1063 /*hasLength=*/true>1064 accumulator{array, operation, identity, terminator};1065 DoTotalReduction<char32_t>(1066 array, dim, mask, accumulator, "REDUCE", terminator);1067 accumulator.GetResult(result);1068}1069void RTDEF(ReduceCharacter4Dim)(Descriptor &result, const Descriptor &array,1070 ReductionCharOperation<char32_t> operation, const char *source, int line,1071 int dim, const Descriptor *mask, const char32_t *identity, bool ordered) {1072 Terminator terminator{source, line};1073 using Accumulator = BufferedReduceAccumulator<char32_t,1074 ReductionCharOperation<char32_t>, /*hasLength=*/true>;1075 Accumulator accumulator{array, operation, identity, terminator};1076 PartialReduction<Accumulator, TypeCategory::Character, 4>(result, array,1077 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);1078}1079 1080void RTDEF(ReduceDerivedType)(char *result, const Descriptor &array,1081 ReductionDerivedTypeOperation operation, const char *source, int line,1082 int dim, const Descriptor *mask, const char *identity, bool ordered) {1083 Terminator terminator{source, line};1084 BufferedReduceAccumulator<char, ReductionDerivedTypeOperation,1085 /*hasLength=*/false>1086 accumulator{array, operation, identity, terminator};1087 DoTotalReduction<char>(array, dim, mask, accumulator, "REDUCE", terminator);1088 accumulator.GetResult(result);1089}1090void RTDEF(ReduceDerivedTypeDim)(Descriptor &result, const Descriptor &array,1091 ReductionDerivedTypeOperation operation, const char *source, int line,1092 int dim, const Descriptor *mask, const char *identity, bool ordered) {1093 Terminator terminator{source, line};1094 using Accumulator = BufferedReduceAccumulator<char,1095 ReductionDerivedTypeOperation, /*hasLength=*/false>;1096 Accumulator accumulator{array, operation, identity, terminator};1097 PartialReduction<Accumulator, TypeCategory::Derived, 0>(result, array,1098 array.ElementBytes(), dim, mask, terminator, "REDUCE", accumulator);1099}1100 1101RT_EXT_API_GROUP_END1102} // extern "C"1103} // namespace Fortran::runtime1104