// Copyright (c) the JPEG XL Project Authors. All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#include "lib/jxl/simd_util.h"

#include <cstddef>

#undef HWY_TARGET_INCLUDE

#define HWY_TARGET_INCLUDE "lib/jxl/simd_util.cc"

#include <hwy/foreach_target.h>

#include <hwy/highway.h>

HWY_BEFORE_NAMESPACE();

namespace jxl {

namespace HWY_NAMESPACE {

using hwy::HWY_NAMESPACE::GetLane;

using hwy::HWY_NAMESPACE::IfThenElseZero;

using hwy::HWY_NAMESPACE::Iota;

using hwy::HWY_NAMESPACE::LoadU;

using hwy::HWY_NAMESPACE::Lt;

using hwy::HWY_NAMESPACE::Max;

using hwy::HWY_NAMESPACE::MaxOfLanes;

using hwy::HWY_NAMESPACE::Set;

size_t MaxVectorSize() {

  HWY_FULL(float) df;

  return Lanes(df) * sizeof(float);

}

jxl::N_SSE4::MaxVectorSize()

Line

Count

Source

28

980k

size_t MaxVectorSize() {

29

980k

  HWY_FULL(float) df;

30

980k

  return Lanes(df) * sizeof(float);

31

980k

}

jxl::N_AVX2::MaxVectorSize()

Line

Count

Source

28

32.1M

size_t MaxVectorSize() {

29

32.1M

  HWY_FULL(float) df;

30

32.1M

  return Lanes(df) * sizeof(float);

31

32.1M

}

jxl::N_SSE2::MaxVectorSize()

Line

Count

Source

28

890k

size_t MaxVectorSize() {

29

890k

  HWY_FULL(float) df;

30

890k

  return Lanes(df) * sizeof(float);

31

890k

}

uint32_t MaxValue(uint32_t* JXL_RESTRICT data, size_t len) {

  HWY_FULL(uint32_t) du;

  size_t last_full = Lanes(du) * (len / Lanes(du));

  auto max = Set(du, 0);

  for (size_t i = 0; i < last_full; i += Lanes(du)) {

    max = Max(max, LoadU(du, data + i));

  }

  if (last_full < len) {

    const auto stop = Set(du, len);

    const auto fence = Iota(du, last_full);

    const auto take = Lt(fence, stop);

    max = Max(max, IfThenElseZero(take, LoadU(du, data + last_full)));

  }

  return GetLane(MaxOfLanes(du, max));

}

Unexecuted instantiation: jxl::N_SSE4::MaxValue(unsigned int*, unsigned long)

jxl::N_AVX2::MaxValue(unsigned int*, unsigned long)

Line

Count

Source

33

1.57k

uint32_t MaxValue(uint32_t* JXL_RESTRICT data, size_t len) {

34

1.57k

  HWY_FULL(uint32_t) du;

35

1.57k

  size_t last_full = Lanes(du) * (len / Lanes(du));

36

1.57k

  auto max = Set(du, 0);

37

2.09k

  for (size_t i = 0; i < last_full; i += Lanes(du)) {

38

524

    max = Max(max, LoadU(du, data + i));

39

524

  }

40

1.57k

  if (last_full < len) {

41

262

    const auto stop = Set(du, len);

42

262

    const auto fence = Iota(du, last_full);

43

262

    const auto take = Lt(fence, stop);

44

262

    max = Max(max, IfThenElseZero(take, LoadU(du, data + last_full)));

45

262

  }

46

1.57k

  return GetLane(MaxOfLanes(du, max));

47

1.57k

}

Unexecuted instantiation: jxl::N_SSE2::MaxValue(unsigned int*, unsigned long)

// NOLINTNEXTLINE(google-readability-namespace-comments)

}  // namespace HWY_NAMESPACE

}  // namespace jxl

HWY_AFTER_NAMESPACE();

#if HWY_ONCE

namespace jxl {

HWY_EXPORT(MaxVectorSize);

HWY_EXPORT(MaxValue);

size_t MaxVectorSize() {

  // Ideally HWY framework should provide us this value.

  // Less than ideal is to check all available targets and choose maximal.

  // As for now, we just ask current active target, assuming it won't change.

  return HWY_DYNAMIC_DISPATCH(MaxVectorSize)();

}

uint32_t MaxValue(uint32_t* JXL_RESTRICT data, size_t len) {

  return HWY_DYNAMIC_DISPATCH(MaxValue)(data, len);

}

}  // namespace jxl

#endif