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 |
|---|---|---|---|---|---|---|
900 | Omega_h::HostWrite<long>::operator[](int) const | inline T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return mirror_(i);
#else
#ifdef OMEGA_H_USE_CUDA
return mirror_[i];
#else
return write_[i];
#endif
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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
movslq -0x1c(%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.hpp |
901 | Omega_h::HostWrite<long>::size() const | LO HostWrite<T>::size() const OMEGA_H_NOEXCEPT {
return write_.size();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22dafd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %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.cpp |
902 | Omega_h::HostWrite<long>::data() const | T* HostWrite<T>::data() const {
#ifdef OMEGA_H_USE_KOKKOS
return mirror_.data();
#elif defined(OMEGA_H_USE_CUDA)
return mirror_.get();
#else
return write_.data();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -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
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
903 | Omega_h::HostWrite<long>::exists() const | OMEGA_H_INLINE bool exists() const OMEGA_H_NOEXCEPT {
return write_.exists();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%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.hpp |
904 | Omega_h::HostWrite<long>::set(int, long) | void HostWrite<T>::set(LO i, T value) {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
mirror_[i] = value;
#elif defined(OMEGA_H_USE_CUDA)
mirror_[std::size_t(i)] = value;
#else
write_[i] = value;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%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.cpp |
905 | Omega_h::HostWrite<long>::get(int) const | T HostWrite<T>::get(LO i) const {
#ifdef OMEGA_H_USE_KOKKOS
return mirror_[i];
#elif defined(OMEGA_H_USE_CUDA)
return mirror_[std::size_t(i)];
#else
return write_[i];
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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
movslq -0x1c(%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.cpp |
906 | Omega_h::HostRead<long>::HostRead(Omega_h::Read<long>) | HostRead<T>::HostRead(Read<T> read) : read_(read) {
ScopedTimer timer("array device to host");
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::View<const T*> dev_view = read.view();
Kokkos::View<const T*, Kokkos::HostSpace> h_view =
Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), read.view());
mirror_ = h_view... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1c3090
leaq 0x3fe813(%rip), %rsi # 0x62c447
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22dc43
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
addq $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.cpp |
907 | Omega_h::HostRead<long>::size() const | LO HostRead<T>::size() const {
return read_.size();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22dcb5
movq -0x30(%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.cpp |
908 | Omega_h::HostRead<long>::operator[](int) const | inline T const& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return mirror_(i);
#else
#ifdef OMEGA_H_USE_CUDA
return mirror_[i];
#else
return read_[i];
#endif
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%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.hpp |
909 | Omega_h::HostRead<long>::data() const | T const* HostRead<T>::data() const {
#if defined(OMEGA_H_USE_KOKKOS)
return mirror_.data();
#elif defined(OMEGA_H_USE_CUDA)
return mirror_.get();
#else
return read_.data();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%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
popq %rbp
retq
nopw (%rax,%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.cpp |
910 | Omega_h::HostRead<long>::get(int) const | T HostRead<T>::get(LO i) const {
return operator[](i);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c6560
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
911 | Omega_h::HostRead<long>::last() const | T HostRead<T>::last() const {
return get(size() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1ce0a0
movq -0x10(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1bf800
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.cpp |
912 | void Omega_h::parallel_for<void Omega_h::fill<long>(Omega_h::Write<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 $0x70, %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 |
913 | void Omega_h::fill<long>(Omega_h::Write<long>, long)::'lambda'(int)::~() | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e1240
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
914 | void Omega_h::parallel_for<void Omega_h::fill_linear<long>(Omega_h::Write<long>, 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 |
915 | void Omega_h::fill_linear<long>(Omega_h::Write<long>, long, long)::'lambda'(int)::~() | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e1240
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
916 | void Omega_h::copy_into<long>(Omega_h::Read<long>, Omega_h::Write<long>) | void copy_into(Read<T> a, Write<T> b) {
OMEGA_H_TIME_FUNCTION;
OMEGA_H_CHECK(a.size() == b.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = a[i]; };
parallel_for(b.size(), f, "copy into kernel");
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x138(%rbp)
movq %rsi, -0x130(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1dfbb0
movq -0x128(%rbp), %rdx
leaq 0x3fe510(%rip), %rsi # 0x62c492
leaq -0xc8(%rbp), %rdi
callq 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_array.cpp |
917 | void Omega_h::parallel_for<void Omega_h::copy_into<long>(Omega_h::Read<long>, Omega_h::Write<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 |
918 | Omega_h::Write<long> Omega_h::deep_copy<long>(Omega_h::Read<long>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T> deep_copy(Read<T> a, std::string const& name) {
OMEGA_H_TIME_FUNCTION;
auto name2 = name.empty() ? a.name() : name;
Write<T> b(a.size(), name2);
copy_into(a, b);
return b;
} | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rsi, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1dfbb0
movq -0x128(%rbp), %rdx
leaq 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.cpp |
919 | double* Omega_h::nonnull<double>(double*) | T* nonnull(T* p) {
return NonNullPtr<T>::get(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bc4c0
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
920 | Omega_h::NonNullPtr<double>::get(double*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22e7bc
movq 0x4c944a(%rip), %rax # 0x6f7c00
movq %rax, -0x10(%rbp)
jmp 0x22e7c4
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%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.cpp |
921 | double const* Omega_h::nonnull<double const>(double const*) | T* nonnull(T* p) {
return NonNullPtr<T>::get(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c5220
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
922 | Omega_h::NonNullPtr<double const>::get(double const*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22e80c
movq 0x4c974a(%rip), %rax # 0x6f7f50
movq %rax, -0x10(%rbp)
jmp 0x22e814
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%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.cpp |
923 | Omega_h::Write<double>::Write(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, std::string const& name_in) {
begin_code("Write allocation");
#ifdef OMEGA_H_USE_KOKKOS
view_ = decltype(view_)(Kokkos::ViewAllocateWithoutInitializing(name_in),
static_cast<std::size_t>(size_in));
#else
shared_alloc_ = decltype(shared_alloc_)(
sizeof(T) * static_cast<std::... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x68(%rbp)
movl %esi, -0x6c(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x3fdb5c(%rip), %rdi # 0x62c3... | 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.cpp |
924 | Omega_h::Write<double>::Write(int, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, T value, std::string const& name_in)
: Write<T>(size_in, name_in) {
fill(*this, value);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1d7b50
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c7e70
jmp 0x22eb7b
movsd... | 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.cpp |
925 | void Omega_h::fill<double>(Omega_h::Write<double>, double) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c7e70
movq -0x60(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x1... | 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.cpp |
926 | Omega_h::Write<double>::Write(int, double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, T offset, T stride, std::string const& name_in)
: Write<T>(size_in, name_in) {
fill_linear(*this, offset, stride);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1d7b50
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 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.cpp |
927 | void Omega_h::fill_linear<double>(Omega_h::Write<double>, double, double) | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c7e70
movq -0x70(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
mov... | 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.cpp |
928 | Omega_h::Write<double>::Write(std::initializer_list<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(std::initializer_list<T> l, std::string const& name_in)
: Write<T>(HostWrite<T>(l, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%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.cpp |
929 | Omega_h::Write<double>::Write(Omega_h::HostWrite<double>) | Write<T>::Write(HostWrite<T> host_write) : Write<T>(host_write.write()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1db430
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d8720
jmp 0x22eeb4
leaq -0x20(%rbp), %rdi
callq 0x1dc900
addq $0x40, %... | 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.cpp |
930 | Omega_h::HostWrite<double>::write() const | Write<T> HostWrite<T>::write() const {
ScopedTimer timer("array host to device");
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::deep_copy(write_.view(), mirror_);
#elif defined(OMEGA_H_USE_CUDA)
auto const err = cudaMemcpy(write_.data(), mirror_.get(),
std::size_t(size()) * sizeof(T), cudaMemcpyHostToDevice);
OMEGA_H... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x3fd4f8(%rip), %rsi # 0x62c432
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
movq -0x38(%r... | 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.cpp |
931 | Omega_h::Write<double>::size() const | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(exists());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return static_cast<LO>(view_.size());
#else
return static_cast<LO>(shared_alloc_.size() / sizeof(T));
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22efc5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22efd4
movq -0x20(%rbp), %ra... | 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.hpp |
932 | Omega_h::Write<double>::operator[](int) const | OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%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
movslq -0x1c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
popq %rbp
retq
| 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.hpp |
933 | Omega_h::Write<double>::data() const | OMEGA_H_INLINE T* data() const noexcept {
#ifdef OMEGA_H_USE_KOKKOS
return view_.data();
#else
return static_cast<T*>(shared_alloc_.data());
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
popq %rbp
retq
nopw (%rax,%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.hpp |
934 | Omega_h::Write<double>::set(int, double) const | void Write<T>::set(LO i, T value) const {
ScopedTimer timer("single host to device");
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_CUDA
cudaMemcpy(data() + i, &value, sizeof(T), cudaMemcpyHostToDevice);
#else
operator[](i) = value;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x39(%rbp), %rdi
leaq 0x3fd3af(%rip), %rsi # 0x62c406
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x48(%rbp), %rcx
movsd -0x38(%rbp), %xmm0
m... | 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.cpp |
935 | Omega_h::Write<double>::get(int) const | T Write<T>::get(LO i) const {
ScopedTimer timer("single device to host");
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_CUDA
T value;
cudaMemcpy(&value, data() + i, sizeof(T), cudaMemcpyDeviceToHost);
return value;
#else
return operator[](i);
#... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x2d(%rbp), %rdi
leaq 0x3fd34a(%rip), %rsi # 0x62c41c
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%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_array.cpp |
936 | Omega_h::Write<double>::use_count() const | inline int use_count() const { return shared_alloc_.alloc->use_count; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.hpp |
937 | Omega_h::Write<double>::exists() const | OMEGA_H_INLINE bool exists() const noexcept {
#if defined(OMEGA_H_USE_KOKKOS)
return view().data() != nullptr
#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && (!defined(__CUDA_ARCH__))
/* deprecated Kokkos behavior: zero-span views have data()==nullptr
*/
|| view().use_count() != 0
#e... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
popq %rbp
retq
| 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.hpp |
938 | Omega_h::Write<double>::name[abi:cxx11]() const | std::string const& Write<T>::name() const {
return shared_alloc_.alloc->name;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
939 | Omega_h::Write<double>::begin() const | OMEGA_H_INLINE T* begin() const noexcept { return data(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -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
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 | gahansen[P]omega_h/src/Omega_h_array.hpp |
940 | Omega_h::Write<double>::end() const | OMEGA_H_INLINE T* end() const OMEGA_H_NOEXCEPT { return data() + size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%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.hpp |
941 | Omega_h::Read<double>::Read() | OMEGA_H_INLINE Read() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c5bc0
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 | gahansen[P]omega_h/src/Omega_h_array.hpp |
942 | Omega_h::Read<double>::Read(Omega_h::Write<double>) | Read<T>::Read(Write<T> write) : write_(write) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7e70
addq $0x10, %rsp
popq %rbp
retq
nop
| 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.cpp |
943 | Omega_h::Read<double>::Read(int, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(LO size_in, T value, std::string const& name_in)
: Read<T>(Write<T>(size_in, value, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1d8d60
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_array.cpp |
944 | Omega_h::Read<double>::Read(int, double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(LO size_in, T offset, T stride, std::string const& name_in)
: Read<T>(Write<T>(size_in, offset, stride, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
leaq -0x38(%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.cpp |
945 | Omega_h::Read<double>::Read(std::initializer_list<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(std::initializer_list<T> l, std::string const& name_in)
: Read<T>(HostWrite<T>(l, name_in).write()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%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.cpp |
946 | Omega_h::Read<double>::size() const | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22f46d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %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.hpp |
947 | Omega_h::Read<double>::operator[](int) const | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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
movslq -0x1c(%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.hpp |
948 | Omega_h::Read<double>::get(int) const | T Read<T>::get(LO i) const {
return write_.get(i);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1bc380
addq $0x10, %rsp
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
949 | Omega_h::Read<double>::first() const | T Read<T>::first() const {
return get(0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1c8390
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.cpp |
950 | Omega_h::Read<double>::last() const | T Read<T>::last() const {
return get(size() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %... | 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.cpp |
951 | Omega_h::Read<double>::exists() const | OMEGA_H_INLINE bool exists() const OMEGA_H_NOEXCEPT {
return write_.exists();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%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.hpp |
952 | Omega_h::Read<double>::name[abi:cxx11]() const | std::string name() const { return write_.name(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddfd0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1c00c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%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.hpp |
953 | Omega_h::Read<double>::begin() const | OMEGA_H_INLINE T const* begin() const noexcept { return data(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%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
popq %rbp
retq
nopw (%rax,%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.hpp |
954 | Omega_h::Read<double>::end() const | OMEGA_H_INLINE T const* end() const noexcept { return data() + size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%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.hpp |
955 | Omega_h::HostWrite<double>::HostWrite(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(LO size_in, std::string const& name_in)
: write_(size_in, name_in)
#ifdef OMEGA_H_USE_KOKKOS
,
mirror_(create_uninit_mirror_view(write_.view()))
#endif
{
#if (!defined(OMEGA_H_USE_KOKKOS)) && defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(write_.size())]);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1cd090
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_array.cpp |
956 | Omega_h::HostWrite<double>::HostWrite(int, double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(
LO size_in, T offset, T stride, std::string const& name_in)
: HostWrite<T>(Write<T>(size_in, offset, stride, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
leaq -0x38(%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.cpp |
957 | Omega_h::HostWrite<double>::HostWrite(Omega_h::Write<double>) | HostWrite<T>::HostWrite(Write<T> write_in)
: write_(write_in)
#ifdef OMEGA_H_USE_KOKKOS
,
mirror_(create_uninit_mirror_view(write_.view()))
#endif
{
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::deep_copy(mirror_, write_.view());
#elif defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(write_.size())]);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7e70
addq $0x10, %rsp
popq %rbp
retq
nop
| 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.cpp |
958 | Omega_h::HostWrite<double>::HostWrite(std::initializer_list<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(std::initializer_list<T> l, std::string const& name_in)
: // an initializer_list should never have over 2 billion items...
HostWrite<T>(static_cast<LO>(l.size()), name_in) {
LO i = 0;
for (auto v : l) operator[](i++) = v;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1d2820
movq -0x50(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x1e31a0
movl $0x0, -0x24(%rbp)
l... | 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.cpp |
959 | std::initializer_list<double>::size() const | constexpr size_type
size() const noexcept { return _M_len; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
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/initializer_list |
960 | std::initializer_list<double>::begin() const | constexpr const_iterator
begin() const noexcept { return _M_array; } | 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/initializer_list |
961 | std::initializer_list<double>::end() const | constexpr const_iterator
end() const noexcept { return begin() + size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1d4c40
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1d2820
movq %rax, %rcx
movq -0x10(%rbp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x20, %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/initializer_list |
962 | Omega_h::HostWrite<double>::operator[](int) const | inline T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return mirror_(i);
#else
#ifdef OMEGA_H_USE_CUDA
return mirror_[i];
#else
return write_[i];
#endif
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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
movslq -0x1c(%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.hpp |
963 | Omega_h::HostWrite<double>::size() const | LO HostWrite<T>::size() const OMEGA_H_NOEXCEPT {
return write_.size();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22f98d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %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.cpp |
964 | Omega_h::HostWrite<double>::data() const | T* HostWrite<T>::data() const {
#ifdef OMEGA_H_USE_KOKKOS
return mirror_.data();
#elif defined(OMEGA_H_USE_CUDA)
return mirror_.get();
#else
return write_.data();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -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
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
965 | Omega_h::HostWrite<double>::exists() const | OMEGA_H_INLINE bool exists() const OMEGA_H_NOEXCEPT {
return write_.exists();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%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.hpp |
966 | Omega_h::HostWrite<double>::set(int, double) | void HostWrite<T>::set(LO i, T value) {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
mirror_[i] = value;
#elif defined(OMEGA_H_USE_CUDA)
mirror_[std::size_t(i)] = value;
#else
write_[i] = value;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%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.cpp |
967 | Omega_h::HostWrite<double>::get(int) const | T HostWrite<T>::get(LO i) const {
#ifdef OMEGA_H_USE_KOKKOS
return mirror_[i];
#elif defined(OMEGA_H_USE_CUDA)
return mirror_[std::size_t(i)];
#else
return write_[i];
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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
movslq -0x1c(%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.cpp |
968 | Omega_h::HostRead<double>::HostRead(Omega_h::Read<double>) | HostRead<T>::HostRead(Read<T> read) : read_(read) {
ScopedTimer timer("array device to host");
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::View<const T*> dev_view = read.view();
Kokkos::View<const T*, Kokkos::HostSpace> h_view =
Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), read.view());
mirror_ = h_view... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1cae10
leaq 0x3fc983(%rip), %rsi # 0x62c447
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22fad3
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
addq $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.cpp |
969 | Omega_h::HostRead<double>::size() const | LO HostRead<T>::size() const {
return read_.size();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22fb45
movq -0x30(%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.cpp |
970 | Omega_h::HostRead<double>::operator[](int) const | inline T const& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return mirror_(i);
#else
#ifdef OMEGA_H_USE_CUDA
return mirror_[i];
#else
return read_[i];
#endif
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%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.hpp |
971 | Omega_h::HostRead<double>::data() const | T const* HostRead<T>::data() const {
#if defined(OMEGA_H_USE_KOKKOS)
return mirror_.data();
#elif defined(OMEGA_H_USE_CUDA)
return mirror_.get();
#else
return read_.data();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%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
popq %rbp
retq
nopw (%rax,%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.cpp |
972 | Omega_h::HostRead<double>::get(int) const | T HostRead<T>::get(LO i) const {
return operator[](i);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1e23e0
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
973 | Omega_h::HostRead<double>::last() const | T HostRead<T>::last() const {
return get(size() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1e0740
movq -0x10(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1dee50
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.cpp |
974 | void Omega_h::parallel_for<void Omega_h::fill<double>(Omega_h::Write<double>, double)::'lambda'(int)>(int, double 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 $0x70, %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 |
975 | void Omega_h::fill<double>(Omega_h::Write<double>, double)::'lambda'(int)::~() | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dc900
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
976 | void Omega_h::parallel_for<void Omega_h::fill_linear<double>(Omega_h::Write<double>, double, double)::'lambda'(int)>(int, double 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 |
977 | void Omega_h::fill_linear<double>(Omega_h::Write<double>, double, double)::'lambda'(int)::~() | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dc900
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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
978 | void Omega_h::copy_into<double>(Omega_h::Read<double>, Omega_h::Write<double>) | void copy_into(Read<T> a, Write<T> b) {
OMEGA_H_TIME_FUNCTION;
OMEGA_H_CHECK(a.size() == b.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = a[i]; };
parallel_for(b.size(), f, "copy into kernel");
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x138(%rbp)
movq %rsi, -0x130(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1dfbb0
movq -0x128(%rbp), %rdx
leaq 0x3fc680(%rip), %rsi # 0x62c492
leaq -0xc8(%rbp), %rdi
callq 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_array.cpp |
979 | void Omega_h::parallel_for<void Omega_h::copy_into<double>(Omega_h::Read<double>, Omega_h::Write<double>)::'lambda'(int)>(int, double 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 |
980 | Omega_h::Write<double> Omega_h::deep_copy<double>(Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T> deep_copy(Read<T> a, std::string const& name) {
OMEGA_H_TIME_FUNCTION;
auto name2 = name.empty() ? a.name() : name;
Write<T> b(a.size(), name2);
copy_into(a, b);
return b;
} | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rsi, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1dfbb0
movq -0x128(%rbp), %rdx
leaq 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.cpp |
981 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::('lambda'(int) const&) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d26b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x10(%rcx), %cl
movb %cl, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
982 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)>(signed char, signed char, void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x230685
jmp 0x230714
movq 0x4... | 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 |
983 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::('lambda'(int)&&) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e2650
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x10(%rcx), %cl
movb %cl, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
984 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::operator()(int) const | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movb 0x10(%rcx), %dl
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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
... | 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.cpp |
985 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::('lambda'(int) const&) | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d26b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movw 0x10(%rcx), %cx
movw %cx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%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.cpp |
986 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)>(signed char, signed char, void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x230825
jmp 0x2308b4
movq 0x4... | 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 |
987 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::('lambda'(int)&&) | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e2650
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movw 0x10(%rcx), %cx
movw %cx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%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.cpp |
988 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::operator()(int) const | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movsbl 0x10(%rcx), %eax
movsbl 0x11(%rcx), %edx
movl -0x2c(%rbp), %esi
movsbl %sil, %esi
imull %esi, %edx
addl %edx, %eax
movb %al, %dl
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%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.cpp |
989 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::copy_into<signed char>(Omega_h::Read<signed char>, Omega_h::Write<signed char>)::'lambda'(int)>(signed char, signed char, void Omega_h::copy_into<signed char>(Omega_h::Read<signed char>, Omega_h::Write<signed char>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x2309f5
jmp 0x230a84
movq 0x4... | 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 |
990 | void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)::('lambda'(int) const&) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c0f10
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
991 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)>(int, int, void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x230bf5
jmp 0x230c84
movq 0x4... | 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 |
992 | void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)::('lambda'(int)&&) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c8620
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| 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.cpp |
993 | void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)::operator()(int) const | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %edx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%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... | 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.cpp |
994 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)::('lambda'(int) const&) | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c0f10
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%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.cpp |
995 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)>(int, int, void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x230d95
jmp 0x230e24
movq 0x4... | 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 |
996 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)::('lambda'(int)&&) | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c8620
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%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.cpp |
997 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)::operator()(int) const | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %edx
movl 0x14(%rcx), %eax
imull -0x2c(%rbp), %eax
addl %eax, %edx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
mo... | 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.cpp |
998 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::copy_into<int>(Omega_h::Read<int>, Omega_h::Write<int>)::'lambda'(int)>(int, int, void Omega_h::copy_into<int>(Omega_h::Read<int>, Omega_h::Write<int>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x230f65
jmp 0x230ff4
movq 0x4... | 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 |
999 | void Omega_h::fill<long>(Omega_h::Write<long>, long)::'lambda'(int)::('lambda'(int) const&) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c78d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%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.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.