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,100 | Omega_h::Read<signed char> Omega_h::each_neq_to<signed char>(Omega_h::Read<signed char>, signed char) | 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)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movb %al, -0x49(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%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,101 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_neq_to<signed char>(Omega_h::Read<signed char>, signed char)::'lambda'(int)>(int, signed char 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,102 | Omega_h::Read<signed char> Omega_h::each_eq<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | 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, -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,103 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_eq<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>)::'lambda'(int)>(int, signed char 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,104 | Omega_h::Read<signed char> Omega_h::each_eq_to<signed char>(Omega_h::Read<signed char>, signed char) | 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)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0xe0(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movb %al, -0x49(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%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,105 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_eq_to<signed char>(Omega_h::Read<signed char>, signed char)::'lambda'(int)>(int, signed char 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,106 | Omega_h::Read<signed char> Omega_h::gt_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | 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, -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,107 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::gt_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>)::'lambda'(int)>(int, signed char 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,108 | Omega_h::Read<signed char> Omega_h::lt_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | 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, -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,109 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::lt_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>)::'lambda'(int)>(int, signed char 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,110 | Omega_h::Read<signed char> Omega_h::eq_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | 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, -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,111 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::eq_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>)::'lambda'(int)>(int, signed char 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,112 | Omega_h::Read<signed char> Omega_h::neq_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | 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, -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,113 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::neq_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>)::'lambda'(int)>(char const*, int, signed char 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 0x1cb730
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,114 | Omega_h::Read<signed char> Omega_h::get_component<signed char>(Omega_h::Read<signed char>, 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,115 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::get_component<signed char>(Omega_h::Read<signed char>, int, int)::'lambda'(int)>(int, signed char 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,116 | void Omega_h::set_component<signed char>(Omega_h::Write<signed char>, Omega_h::Read<signed char>, 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 0x1d26b0
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,117 | void Omega_h::parallel_for<void Omega_h::set_component<signed char>(Omega_h::Write<signed char>, Omega_h::Read<signed char>, int, int)::'lambda'(int)>(int, signed char 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,118 | void Omega_h::set_component<signed char>(Omega_h::Write<signed char>, Omega_h::Read<signed char>, 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 0x1e0060
movq -0x10(%rbp), %rdi
callq 0x1d4740
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,119 | int Omega_h::find_last<signed char>(Omega_h::Read<signed char>, signed char) | 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)
movb %sil, %al
movq %rdi, -0x48(%rbp)
movb %al, -0x49(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -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_array_ops.cpp |
1,120 | int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::find_last<signed char>(Omega_h::Read<signed char>, signed char)::'lambda'(int), int, Omega_h::maximum<int>>(signed char, signed char, int, Omega_h::maximum<int>, int Omega_h::find_last<signed char>(Omega_h::Read<signed char>, signed char)::'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 0x4b8bb9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1d6590
movq 0x4b8ba2(%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,121 | bool Omega_h::is_sorted<signed char>(Omega_h::Read<signed char>) | 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 $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x23f245
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,122 | bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::is_sorted<signed char>(Omega_h::Read<signed char>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(signed char, signed char, bool, Omega_h::logical_and<bool>, bool Omega_h::is_sorted<signed char>(Omega_h::Read<signed char>)::'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 0x4b88c5(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1d4c60
movq 0x4b88ae(%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,123 | Omega_h::Read<signed char> Omega_h::interleave<signed char>(std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>) | 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 0x1d2db0
testb $0x1, %al
jne 0x23f510
jmp 0x23f543
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,124 | std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>::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 0x1bdfa0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1cebd0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1cc9f0
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,125 | std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>::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,126 | std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>::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 0x1d1290
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1d09c0
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,127 | std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>::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 0x1db5d0
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,128 | std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>::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 0x1db5d0
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,129 | _gnu_cxx::__normal_iterator<Omega_h::Read<signed char>*, std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>>::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,130 | std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>::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,131 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::interleave<signed char>(std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>)::'lambda'(int)>(int, signed char 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,132 | Omega_h::Read<signed char> Omega_h::coalesce<signed char>(std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>) | 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 0x1d2db0
testb $0x1, %al
jne 0x23fbe0
jmp 0x23fc13
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,133 | std::allocator<int>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e1930
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/allocator.h |
1,134 | std::vector<int, std::allocator<int>>::vector(unsigned long, std::allocator<int> const&) | explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: _Base(_S_check_init_len(__n, __a), __a)
{ _M_default_initialize(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ca2b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1d16e0
movq -0x30(%rbp), %rdi
mo... | 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,135 | std::allocator<int>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ba140
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/allocator.h |
1,136 | std::vector<int, std::allocator<int>>::data() | _Tp*
data() _GLIBCXX_NOEXCEPT
{ return _M_data_ptr(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rsi
callq 0x1c6b10
addq $0x10, %rsp
popq %rbp
retq
nop
| 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,137 | std::vector<int, std::allocator<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 $0x2, %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,138 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::coalesce<signed char>(std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>)::'lambda'(int)>(int, signed char 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,139 | std::vector<int, std::allocator<int>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x1d5e40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1bbf10
jmp 0x24032a
movq -0x20(%rbp), %... | 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,140 | bool Omega_h::operator==<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,141 | bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::operator==<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(int, int, bool, Omega_h::logical_and<bool>, bool Omega_h::operator==<int>(Omega_h::Read<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 $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 0x4b7685(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1df890
movq 0x4b766e(%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,142 | Omega_h::Promoted<int>::type Omega_h::get_sum<int>(Omega_h::Read<int>) | 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,143 | int Omega_h::transform_reduce<int const*, Omega_h::Promoted<int>::type Omega_h::get_sum<int>(Omega_h::Read<int>)::'lambda'(int), int, Omega_h::plus<int>>(int, int, int, Omega_h::plus<int>, Omega_h::Promoted<int>::type Omega_h::get_sum<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 $0x50, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movq %rcx, -0x40(%rbp)
movq 0x4b744a(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq 0x4b7440(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x24089c
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,144 | int Omega_h::get_min<int>(Omega_h::Read<int>) | 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 $0xb0, %rsp
movq %rdi, -0x98(%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,145 | int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::get_min<int>(Omega_h::Read<int>)::'lambda'(int), int, Omega_h::minimum<int>>(int, int, int, Omega_h::minimum<int>, int Omega_h::get_min<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
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
movl %edx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4b7279(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1d3270
movq 0x4b7262(%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,146 | int Omega_h::get_max<int>(Omega_h::Read<int>) | 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 $0xb0, %rsp
movq %rdi, -0x98(%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,147 | int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::get_max<int>(Omega_h::Read<int>)::'lambda'(int), int, Omega_h::maximum<int>>(int, int, int, Omega_h::maximum<int>, int Omega_h::get_max<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
movl %edi, -0x3c(%rbp)
movl %esi, -0x40(%rbp)
movl %edx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x4b7009(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1c33e0
movq 0x4b6ff2(%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,148 | Omega_h::Promoted<int>::type Omega_h::get_sum<int>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<int>) | 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 $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1d9de0
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1d99b0
movq -0x38(%rbp), %rdi
callq 0x1cc3b0
movl %eax, -0x30(%rbp)
jmp 0x240dcc
movl -0x30(%... | 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,149 | int Omega_h::get_min<int>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<int>) | T get_min(CommPtr comm, Read<T> a) {
return comm->allreduce(get_min(a), OMEGA_H_MIN);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1d9de0
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1d99b0
movq -0x38(%rbp), %rdi
callq 0x1c7e60
movl %eax, -0x30(%rbp)
jmp 0x240e5c
movl -0x30(%... | 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,150 | int Omega_h::get_max<int>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<int>) | T get_max(CommPtr comm, Read<T> a) {
return comm->allreduce(get_max(a), OMEGA_H_MAX);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1d9de0
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1d99b0
movq -0x38(%rbp), %rdi
callq 0x1bb7d0
movl %eax, -0x30(%rbp)
jmp 0x240edc
movl -0x30(%... | 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,151 | Omega_h::MinMax<int> Omega_h::get_minmax<int>(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<int>) | 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, -0x80(%rbp)
movq %rax, -0x70(%rbp)
movq %rsi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1d9d90
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1d99b0
jmp 0x24... | 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,152 | Omega_h::Write<int> Omega_h::multiply_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, 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,153 | void Omega_h::parallel_for<Omega_h::Write<int> Omega_h::multiply_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'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 $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,154 | Omega_h::Read<int> Omega_h::multiply_each_by<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x54(%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,155 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::multiply_each_by<int>(Omega_h::Read<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,156 | Omega_h::Read<int> Omega_h::divide_each_by<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x54(%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,157 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::divide_each_by<int>(Omega_h::Read<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,158 | Omega_h::Write<int> Omega_h::divide_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, 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,159 | void Omega_h::parallel_for<Omega_h::Write<int> Omega_h::divide_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'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 $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,160 | Omega_h::Read<int> Omega_h::add_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, 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,161 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::add_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'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 $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,162 | Omega_h::Read<int> Omega_h::subtract_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,163 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::subtract_each<int>(Omega_h::Read<int>, 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 $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,164 | Omega_h::Read<int> Omega_h::min_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,165 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::min_each<int>(Omega_h::Read<int>, 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 $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,166 | Omega_h::Read<int> Omega_h::max_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,167 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::max_each<int>(Omega_h::Read<int>, 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 $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,168 | Omega_h::Read<int> Omega_h::ternary_each<int>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Read<int>) | 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,169 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::ternary_each<int>(Omega_h::Read<signed char>, Omega_h::Read<int>, 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 $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,170 | Omega_h::Read<int> Omega_h::each_max_with<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,171 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::each_max_with<int>(Omega_h::Read<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,172 | Omega_h::Read<int> Omega_h::add_to_each<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,173 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::add_to_each<int>(Omega_h::Read<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,174 | Omega_h::Read<int> Omega_h::subtract_from_each<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,175 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::subtract_from_each<int>(Omega_h::Read<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,176 | Omega_h::Read<signed char> Omega_h::each_geq_to<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,177 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_geq_to<int>(Omega_h::Read<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,178 | Omega_h::Read<signed char> Omega_h::each_leq_to<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,179 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_leq_to<int>(Omega_h::Read<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,180 | Omega_h::Read<signed char> Omega_h::each_gt<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,181 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_gt<int>(Omega_h::Read<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,182 | Omega_h::Read<signed char> Omega_h::each_lt<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,183 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_lt<int>(Omega_h::Read<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,184 | Omega_h::Read<signed char> Omega_h::each_neq_to<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,185 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_neq_to<int>(Omega_h::Read<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,186 | Omega_h::Read<signed char> Omega_h::each_eq<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,187 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_eq<int>(Omega_h::Read<int>, 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 $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,188 | Omega_h::Read<signed char> Omega_h::each_eq_to<int>(Omega_h::Read<int>, int) | 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)
movl %edx, -0x4c(%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,189 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::each_eq_to<int>(Omega_h::Read<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,190 | Omega_h::Read<signed char> Omega_h::gt_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,191 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::gt_each<int>(Omega_h::Read<int>, 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 $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,192 | Omega_h::Read<signed char> Omega_h::lt_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,193 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::lt_each<int>(Omega_h::Read<int>, 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 $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,194 | Omega_h::Read<signed char> Omega_h::eq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,195 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::eq_each<int>(Omega_h::Read<int>, 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 $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,196 | Omega_h::Read<signed char> Omega_h::neq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>) | 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,197 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::neq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int)>(char const*, int, int 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 0x1cbec0
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,198 | Omega_h::Read<int> Omega_h::get_component<int>(Omega_h::Read<int>, 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,199 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::get_component<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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.