idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1
value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
1,200 | void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int) | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rax, -0x78(%rbp)
movq %rsi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movl %ecx, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1c0f10
movq -0x78(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, -0x50(%rbp)... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,201 | void Omega_h::parallel_for<void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int)::'lambda'(int)>(int, int const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,202 | void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int)::'lambda'(int)::~() | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
callq 0x1c7d90
movq -0x10(%rbp), %rdi
callq 0x1dfdc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,203 | int Omega_h::find_last<int>(Omega_h::Read<int>, int) | LO find_last(Read<T> array, T value) {
auto const first = IntIterator(0);
auto const last = IntIterator(array.size());
auto const init = -1;
auto const op = maximum<LO>();
auto transform = OMEGA_H_LAMBDA(LO i)->LO {
if (array[i] == value)
return i;
else
return -1;
};
return transform_r... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x48(%rbp)
movl %esi, -0x4c(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,204 | int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::find_last<int>(Omega_h::Read<int>, int)::'lambda'(int), int, Omega_h::maximum<int>>(int, int, int, Omega_h::maximum<int>, int Omega_h::find_last<int>(Omega_h::Read<int>, int)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
movl %edx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4b0329(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1d88c0
movq 0x4b0312(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,205 | bool Omega_h::is_sorted<int>(Omega_h::Read<int>) | bool is_sorted(Read<T> a) {
if (a.size() < 2) return true;
auto const first = IntIterator(0);
auto const last = IntIterator(a.size() - 1);
auto const init = true;
auto const op = logical_and<bool>();
auto transform = OMEGA_H_LAMBDA(LO i)->bool { return a[i] <= a[i + 1]; };
return transform_reduce(first, l... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x247ad5
movq -... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,206 | bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::is_sorted<int>(Omega_h::Read<int>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(int, int, bool, Omega_h::logical_and<bool>, bool Omega_h::is_sorted<int>(Omega_h::Read<int>)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x42(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4b0025(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1caa50
movq 0x4b000e(%rip), %rax # 0x6f7c... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,207 | Omega_h::Read<int> Omega_h::interleave<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>) | Read<T> interleave(std::vector<Read<T>> arrays) {
if (arrays.empty()) return Read<T>();
auto narrays = LO(arrays.size());
auto array_size = arrays.front().size();
for (auto& array : arrays) OMEGA_H_CHECK(array.size() == array_size);
auto out_size = narrays * array_size;
auto out = Write<T>(out_size);
for ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rsi, -0x140(%rbp)
movq %rdi, %rax
movq -0x140(%rbp), %rdi
movq %rax, -0x138(%rbp)
movq %rax, %rcx
movq %rcx, -0x130(%rbp)
movq %rax, -0x60(%rbp)
movq %rdi, -0x68(%rbp)
callq 0x1ccbb0
testb $0x1, %al
jne 0x247db0
jmp 0x247de3
movq -0x138(%rbp), ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,208 | std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>::empty() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return begin() == end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1ca900
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1be460
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c03e0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
no... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,209 | std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,210 | std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>::front() | reference
front() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *begin();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cee50
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1daa80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,211 | std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1cfc40
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,212 | std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1cfc40
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,213 | _gnu_cxx::__normal_iterator<Omega_h::Read<int>*, std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
1,214 | std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>::operator[](unsigned long) | reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,215 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::interleave<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>)::'lambda'(int)>(int, int const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,216 | Omega_h::Read<int> Omega_h::coalesce<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>) | Read<T> coalesce(std::vector<Read<T>> arrays) {
if (arrays.empty()) return Read<T>();
std::vector<LO> offsets(arrays.size() + 1);
OMEGA_H_CHECK(offsets.data() != nullptr);
offsets[0] = 0;
for (std::size_t i = 1; i <= arrays.size(); ++i) {
offsets[i] = offsets[i - 1] + arrays[i].size();
}
auto out_size... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, -0x150(%rbp)
movq %rdi, %rax
movq -0x150(%rbp), %rdi
movq %rax, -0x148(%rbp)
movq %rax, %rcx
movq %rcx, -0x140(%rbp)
movq %rax, -0x60(%rbp)
movq %rdi, -0x68(%rbp)
callq 0x1ccbb0
testb $0x1, %al
jne 0x248480
jmp 0x2484b3
movq -0x148(%rbp), ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,217 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::coalesce<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>)::'lambda'(int)>(int, int const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,218 | bool Omega_h::operator==<long>(Omega_h::Read<long>, Omega_h::Read<long>) | bool operator==(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = true;
auto const op = logical_and<bool>();
auto transform = OMEGA_H_LAMBDA(LO i)->bool { return a[i] == b[i]; };
return transform_reduc... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xf0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdi, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rb... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,219 | bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::operator==<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(long, long, bool, Omega_h::logical_and<bool>, bool Omega_h::operator==<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x42(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4aef35(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1e4000
movq 0x4aef1e(%rip), %rax # 0x6f7c... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,220 | Omega_h::Promoted<long>::type Omega_h::get_sum<long>(Omega_h::Read<long>) | promoted_t<T> get_sum(Read<T> a) {
using PT = promoted_t<T>;
return transform_reduce(a.begin(), a.end(), PT(0), plus<PT>(),
OMEGA_H_LAMBDA(T val)->PT { return PT(val); });
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x58(%rbp)
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,221 | long Omega_h::transform_reduce<long const*, Omega_h::Promoted<long>::type Omega_h::get_sum<long>(Omega_h::Read<long>)::'lambda'(long), long, Omega_h::plus<long>>(long, long, long, Omega_h::plus<long>, Omega_h::Promoted<long>::type Omega_h::get_sum<long>(Omega_h::Read<long>)::'lambda'(long)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq 0x4aecf9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq 0x4aecef(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x248ff2
movq -0x28... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,222 | long Omega_h::get_min<long>(Omega_h::Read<long>) | T get_min(Read<T> a) {
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = promoted_t<T>(ArithTraits<T>::max());
auto const op = minimum<promoted_t<T>>();
auto transform = OMEGA_H_LAMBDA(LO i)->promoted_t<T> {
return promoted_t<T>(a[i]);
};
auto const r = tran... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x48(%rbp)
leaq -0x4c(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,223 | long Omega_h::transform_reduce<Omega_h::IntIterator, long Omega_h::get_min<long>(Omega_h::Read<long>)::'lambda'(int), long, Omega_h::minimum<long>>(long, long, long, Omega_h::minimum<long>, long Omega_h::get_min<long>(Omega_h::Read<long>)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
movq %rdx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movq 0x4aeb18(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x58(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1bcf50
movq 0x4aeb01(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,224 | long Omega_h::get_max<long>(Omega_h::Read<long>) | T get_max(Read<T> a) {
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = promoted_t<T>(ArithTraits<T>::min());
auto const op = maximum<promoted_t<T>>();
auto transform = OMEGA_H_LAMBDA(LO i)->promoted_t<T> {
return promoted_t<T>(a[i]);
};
auto const r = tran... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x48(%rbp)
leaq -0x4c(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,225 | long Omega_h::transform_reduce<Omega_h::IntIterator, long Omega_h::get_max<long>(Omega_h::Read<long>)::'lambda'(int), long, Omega_h::maximum<long>>(long, long, long, Omega_h::maximum<long>, long Omega_h::get_max<long>(Omega_h::Read<long>)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
movq %rdx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movq 0x4ae868(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x58(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1cff00
movq 0x4ae851(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,226 | Omega_h::Promoted<long>::type Omega_h::get_sum<long>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>) | promoted_t<T> get_sum(CommPtr comm, Read<T> a) {
return comm->allreduce(get_sum(a), OMEGA_H_SUM);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1d9de0
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1c3090
movq -0x40(%rbp), %rdi
callq 0x1c7380
movq %rax, -0x38(%rbp)
jmp 0x24959d
movq -0x38(%... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,227 | long Omega_h::get_min<long>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>) | T get_min(CommPtr comm, Read<T> a) {
return comm->allreduce(get_min(a), OMEGA_H_MIN);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1d9de0
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1c3090
movq -0x40(%rbp), %rdi
callq 0x1e4be0
movq %rax, -0x38(%rbp)
jmp 0x24962d
movq -0x38(%... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,228 | long Omega_h::get_max<long>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>) | T get_max(CommPtr comm, Read<T> a) {
return comm->allreduce(get_max(a), OMEGA_H_MAX);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1d9de0
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1c3090
movq -0x40(%rbp), %rdi
callq 0x1d28d0
movq %rax, -0x38(%rbp)
jmp 0x2496bd
movq -0x38(%... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,229 | Omega_h::MinMax<long> Omega_h::get_minmax<long>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>) | MinMax<T> get_minmax(CommPtr comm, Read<T> a) {
return {get_min(comm, a), get_max(comm, a)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x88(%rbp)
movq %rax, -0x78(%rbp)
movq %rsi, -0x18(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d9d90
movq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c3090
jmp 0x2... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,230 | Omega_h::Write<long> Omega_h::multiply_each<long>(Omega_h::Read<long>, Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T> multiply_each(Read<T> a, Read<T> b, std::string const& name) {
Write<T> c(a.size(), name);
if (b.size() == 0) {
OMEGA_H_CHECK(a.size() == 0);
return c;
}
auto width = divide_no_remainder(a.size(), b.size());
auto f = OMEGA_H_LAMBDA(LO i) {
for (Int j = 0; j < width; ++j) {
c[i * wid... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, -0x160(%rbp)
movq %rsi, -0x158(%rbp)
movq %rdi, -0x150(%rbp)
movq %rdi, %rax
movq %rax, -0x148(%rbp)
movq %rdi, -0xc8(%rbp)
movq %rsi, -0xd0(%rbp)
movq %rdx, -0xd8(%rbp)
movq %rcx, -0xe0(%rbp)
movb $0x0, -0xe1(%rbp)
movq %rsi, -0x98(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,231 | void Omega_h::parallel_for<Omega_h::Write<long> Omega_h::multiply_each<long>(Omega_h::Read<long>, Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,232 | Omega_h::Read<long> Omega_h::multiply_each_by<long>(Omega_h::Read<long>, long) | Read<T> multiply_each_by(Read<T> a, T b) {
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = a[i] * b; };
parallel_for(a.size(), f, "multiply_each_by");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0xf8(%rbp)
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,233 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::multiply_each_by<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,234 | Omega_h::Read<long> Omega_h::divide_each_by<long>(Omega_h::Read<long>, long) | Read<T> divide_each_by(Read<T> a, T b) {
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = a[i] / b; };
parallel_for(a.size(), f, "divide_each_by");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0xf8(%rbp)
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,235 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::divide_each_by<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,236 | Omega_h::Write<long> Omega_h::divide_each<long>(Omega_h::Read<long>, Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T> divide_each(Read<T> a, Read<T> b, std::string const& name) {
auto width = divide_no_remainder(a.size(), b.size());
Write<T> c(a.size(), name);
auto f = OMEGA_H_LAMBDA(LO i) {
for (Int j = 0; j < width; ++j) {
c[i * width + j] = a[i * width + j] / b[i];
}
};
parallel_for(b.size(), f, "di... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdx, -0x118(%rbp)
movq %rsi, -0x110(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movq %rsi, -0x68(%rbp)
movq -0x68(%rbp), %rax
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,237 | void Omega_h::parallel_for<Omega_h::Write<long> Omega_h::divide_each<long>(Omega_h::Read<long>, Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,238 | Omega_h::Read<long> Omega_h::add_each<long>(Omega_h::Read<long>, Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T> add_each(Read<T> a, Read<T> b, std::string const& name) {
OMEGA_H_CHECK(a.size() == b.size());
Write<T> c(a.size(), name);
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = a[i] + b[i]; };
parallel_for(c.size(), f, "add_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdx, -0x120(%rbp)
movq %rsi, -0x118(%rbp)
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rcx, -0x98(%rbp)
movq %rsi, -0x68(%rbp)
movq -0x68(%rbp), %rax
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,239 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::add_each<long>(Omega_h::Read<long>, Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,240 | Omega_h::Read<long> Omega_h::subtract_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Read<T> subtract_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = a[i] - b[i]; };
parallel_for(c.size(), f, "subtract_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,241 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::subtract_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,242 | Omega_h::Read<long> Omega_h::min_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Read<T> min_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = min2(a[i], b[i]); };
parallel_for(c.size(), f, "min_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,243 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::min_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,244 | Omega_h::Read<long> Omega_h::max_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Read<T> max_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = max2(a[i], b[i]); };
parallel_for(c.size(), f, "max_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,245 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::max_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,246 | Omega_h::Read<long> Omega_h::ternary_each<long>(Omega_h::Read<signed char>, Omega_h::Read<long>, Omega_h::Read<long>) | Read<T> ternary_each(Bytes cond, Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
auto width = divide_no_remainder(a.size(), cond.size());
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = cond[i / width] ? a[i] : b[i]; };
parallel_for(c.size(), f, "ternary_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rcx, -0x1b0(%rbp)
movq %rdx, -0x1a8(%rbp)
movq %rsi, -0x1a0(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0x90(%rbp)... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,247 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::ternary_each<long>(Omega_h::Read<signed char>, Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,248 | Omega_h::Read<long> Omega_h::each_max_with<long>(Omega_h::Read<long>, long) | Read<T> each_max_with(Read<T> a, T b) {
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = max2(a[i], b); };
parallel_for(c.size(), f, "each_max_with");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,249 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::each_max_with<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,250 | Omega_h::Read<long> Omega_h::add_to_each<long>(Omega_h::Read<long>, long) | Read<T> add_to_each(Read<T> a, T b) {
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = a[i] + b; };
parallel_for(c.size(), f, "add_to_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,251 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::add_to_each<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,252 | Omega_h::Read<long> Omega_h::subtract_from_each<long>(Omega_h::Read<long>, long) | Read<T> subtract_from_each(Read<T> a, T b) {
Write<T> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = a[i] - b; };
parallel_for(c.size(), f, "subtract_from_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,253 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::subtract_from_each<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,254 | Omega_h::Read<signed char> Omega_h::each_geq_to<long>(Omega_h::Read<long>, long) | Bytes each_geq_to(Read<T> a, T b) {
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] >= b); };
parallel_for(c.size(), f, "each_geq_to");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,255 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_geq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,256 | Omega_h::Read<signed char> Omega_h::each_leq_to<long>(Omega_h::Read<long>, long) | Bytes each_leq_to(Read<T> a, T b) {
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] <= b); };
parallel_for(c.size(), f, "each_leq_to");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,257 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_leq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,258 | Omega_h::Read<signed char> Omega_h::each_gt<long>(Omega_h::Read<long>, long) | Bytes each_gt(Read<T> a, T b) {
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] > b); };
parallel_for(c.size(), f, "each_gt");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,259 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_gt<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,260 | Omega_h::Read<signed char> Omega_h::each_lt<long>(Omega_h::Read<long>, long) | Bytes each_lt(Read<T> a, T b) {
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] < b); };
parallel_for(c.size(), f, "each_lt");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,261 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_lt<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,262 | Omega_h::Read<signed char> Omega_h::each_neq_to<long>(Omega_h::Read<long>, long) | Bytes each_neq_to(Read<T> a, T b) {
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] != b); };
parallel_for(c.size(), f, "each_neq_to");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,263 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_neq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,264 | Omega_h::Read<signed char> Omega_h::each_eq<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Bytes each_eq(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] == b[i]); };
parallel_for(c.size(), f, "each_eq");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,265 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_eq<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,266 | Omega_h::Read<signed char> Omega_h::each_eq_to<long>(Omega_h::Read<long>, long) | Bytes each_eq_to(Read<T> a, T b) {
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] == b); };
parallel_for(c.size(), f, "each_eq_to");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,267 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_eq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,268 | Omega_h::Read<signed char> Omega_h::gt_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Bytes gt_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] > b[i]); };
parallel_for(c.size(), f, "gt_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,269 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::gt_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,270 | Omega_h::Read<signed char> Omega_h::lt_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Bytes lt_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] < b[i]); };
parallel_for(c.size(), f, "lt_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,271 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::lt_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,272 | Omega_h::Read<signed char> Omega_h::eq_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Bytes eq_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] == b[i]); };
parallel_for(c.size(), f, "eq_each");
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,273 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::eq_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,274 | Omega_h::Read<signed char> Omega_h::neq_each<long>(Omega_h::Read<long>, Omega_h::Read<long>) | Bytes neq_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] != b[i]); };
parallel_for("neq_each", c.size(), std::move(f));
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdx, -0x140(%rbp)
movq %rsi, -0x138(%rbp)
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,275 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::neq_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(char const*, int, long const&) | void parallel_for(char const* name, LO n, T const& f) {
parallel_for(n, f, name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x1d31e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,276 | Omega_h::Read<long> Omega_h::get_component<long>(Omega_h::Read<long>, int, int) | Read<T> get_component(Read<T> a, Int ncomps, Int comp) {
Write<T> b(divide_no_remainder(a.size(), ncomps));
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = a[i * ncomps + comp]; };
parallel_for(b.size(), f, "get_component");
return b;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rsi, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movl %edx, -0x4c(%rbp)
movl %ecx, -0x50(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,277 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::get_component<long>(Omega_h::Read<long>, int, int)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,278 | void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int) | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rax, -0x78(%rbp)
movq %rsi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movl %ecx, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1c78d0
movq -0x78(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, -0x50(%rbp)... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,279 | void Omega_h::parallel_for<void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,280 | void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)::~() | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
callq 0x1bc010
movq -0x10(%rbp), %rdi
callq 0x1e1240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,281 | int Omega_h::find_last<long>(Omega_h::Read<long>, long) | LO find_last(Read<T> array, T value) {
auto const first = IntIterator(0);
auto const last = IntIterator(array.size());
auto const init = -1;
auto const op = maximum<LO>();
auto transform = OMEGA_H_LAMBDA(LO i)->LO {
if (array[i] == value)
return i;
else
return -1;
};
return transform_r... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
leaq -0x54(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,282 | int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::find_last<long>(Omega_h::Read<long>, long)::'lambda'(int), int, Omega_h::maximum<int>>(long, long, int, Omega_h::maximum<int>, int Omega_h::find_last<long>(Omega_h::Read<long>, long)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
movl %edx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4a7b29(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1ddc50
movq 0x4a7b12(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,283 | bool Omega_h::is_sorted<long>(Omega_h::Read<long>) | bool is_sorted(Read<T> a) {
if (a.size() < 2) return true;
auto const first = IntIterator(0);
auto const last = IntIterator(a.size() - 1);
auto const init = true;
auto const op = logical_and<bool>();
auto transform = OMEGA_H_LAMBDA(LO i)->bool { return a[i] <= a[i + 1]; };
return transform_reduce(first, l... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x2502d5
movq -... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,284 | bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::is_sorted<long>(Omega_h::Read<long>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(long, long, bool, Omega_h::logical_and<bool>, bool Omega_h::is_sorted<long>(Omega_h::Read<long>)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x42(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4a7825(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1c4690
movq 0x4a780e(%rip), %rax # 0x6f7c... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,285 | Omega_h::Read<long> Omega_h::interleave<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>) | Read<T> interleave(std::vector<Read<T>> arrays) {
if (arrays.empty()) return Read<T>();
auto narrays = LO(arrays.size());
auto array_size = arrays.front().size();
for (auto& array : arrays) OMEGA_H_CHECK(array.size() == array_size);
auto out_size = narrays * array_size;
auto out = Write<T>(out_size);
for ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rsi, -0x140(%rbp)
movq %rdi, %rax
movq -0x140(%rbp), %rdi
movq %rax, -0x138(%rbp)
movq %rax, %rcx
movq %rcx, -0x130(%rbp)
movq %rax, -0x60(%rbp)
movq %rdi, -0x68(%rbp)
callq 0x1d5db0
testb $0x1, %al
jne 0x2505b0
jmp 0x2505e3
movq -0x138(%rbp), ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,286 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::empty() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return begin() == end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1d7a20
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1b8600
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1bd430
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
no... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,287 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,288 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::front() | reference
front() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *begin();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c4cb0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1cc3e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,289 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d4860
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,290 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d4860
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,291 | _gnu_cxx::__normal_iterator<Omega_h::Read<long>*, std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
1,292 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::operator[](unsigned long) | reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,293 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::interleave<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,294 | Omega_h::Read<long> Omega_h::coalesce<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>) | Read<T> coalesce(std::vector<Read<T>> arrays) {
if (arrays.empty()) return Read<T>();
std::vector<LO> offsets(arrays.size() + 1);
OMEGA_H_CHECK(offsets.data() != nullptr);
offsets[0] = 0;
for (std::size_t i = 1; i <= arrays.size(); ++i) {
offsets[i] = offsets[i - 1] + arrays[i].size();
}
auto out_size... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, -0x150(%rbp)
movq %rdi, %rax
movq -0x150(%rbp), %rdi
movq %rax, -0x148(%rbp)
movq %rax, %rcx
movq %rcx, -0x140(%rbp)
movq %rax, -0x60(%rbp)
movq %rdi, -0x68(%rbp)
callq 0x1d5db0
testb $0x1, %al
jne 0x250c80
jmp 0x250cb3
movq -0x148(%rbp), ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,295 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::coalesce<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,296 | bool Omega_h::operator==<double>(Omega_h::Read<double>, Omega_h::Read<double>) | bool operator==(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = true;
auto const op = logical_and<bool>();
auto transform = OMEGA_H_LAMBDA(LO i)->bool { return a[i] == b[i]; };
return transform_reduc... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xf0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdi, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rb... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,297 | bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::operator==<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(double, double, bool, Omega_h::logical_and<bool>, bool Omega_h::operator==<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'... | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x42(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4a6735(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1bf950
movq 0x4a671e(%rip), %rax # 0x6f7c... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
1,298 | Omega_h::Promoted<double>::type Omega_h::get_sum<double>(Omega_h::Read<double>) | promoted_t<T> get_sum(Read<T> a) {
using PT = promoted_t<T>;
return transform_reduce(a.begin(), a.end(), PT(0), plus<PT>(),
OMEGA_H_LAMBDA(T val)->PT { return PT(val); });
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x58(%rbp)
movq... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,299 | double Omega_h::transform_reduce<double const*, Omega_h::Promoted<double>::type Omega_h::get_sum<double>(Omega_h::Read<double>)::'lambda'(double), double, Omega_h::plus<double>>(double, double, double, Omega_h::plus<double>, Omega_h::Promoted<double>::type Omega_h::get_sum<double>(Omega_h::Read<double>)::'lambda'(doubl... | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x4a64f8(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq 0x4a64ee(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x2517f8
movq -0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reduce.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.