name string | code string | asm string | file string |
|---|---|---|---|
releaseMonitor | static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver se... | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpq %rbx, 0x18(%rdi)
jne 0x26886
xorl %esi, %esi
callq 0x1f826
movq 0x40(%rbx), %rdi
callq 0x24cfe
leaq 0x34192(%rip), %rax # 0x5aa10
decl 0x20d20(%rax)
je 0x26888
popq %rbx
retq
movq 0x1fec0(%rax), %rdi
movl 0x20d24(%rax), %esi
movl 0x20d28(%rax), %edx
movl 0x20d2c... | /Tigermouthbear[P]flappytiger/external/glfw/src/x11_window.c |
glfwPlatformSetWindowPos | void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
{
// HACK: Explicitly setting PPosition to any value causes some WMs, notably
// Compiz and Metacity, to honor the position of unmapped windows
if (!_glfwPlatformWindowVisible(window))
{
long supplied;
XSizeHin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x33e7f(%rip), %r12 # 0x5aa10
movq 0x1fec0(%r12), %rdi
movq 0x348(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x14850
cmpl $0x2, 0x5c(%r15)
je 0x26c07
callq 0x148b0
movq %rax, %r15... | /Tigermouthbear[P]flappytiger/external/glfw/src/x11_window.c |
glfwPlatformRequestWindowAttention | void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
{
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
return;
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x33468(%rip), %r15 # 0x5aa10
movq 0x20b20(%r15), %r13
movq 0x20b48(%r15), %r12
testq %r13, %r13
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x27634
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
xorl %ebp, %ebp
... | /Tigermouthbear[P]flappytiger/external/glfw/src/x11_window.c |
glfwInitEGL | GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_EGL_LIBRARY)
_GLFW_EGL_LIBRARY,
#elif defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#elif defined(__CYGWIN__)
"libEGL-1.so",
#else
"libE... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x2f8a9(%rip), %r14 # 0x5aa10
movl $0x1, %ebx
cmpq $0x0, 0x20fb0(%r14)
jne 0x2b53a
leaq 0x25fd9(%rip), %rdi # 0x5115a
movl $0x1, %esi
callq 0x14520
movq %rax, 0x20fb0(%r14)
testq %rax, %rax
je 0x2b4ca
movl $0x1, 0x20f98(%r14)
leaq 0x25fd4(%rip), %rsi # 0x51181
movq %rax... | /Tigermouthbear[P]flappytiger/external/glfw/src/egl_context.c |
getEGLErrorString | static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
... | addl $0xffffd000, %edi # imm = 0xFFFFD000
cmpl $0xe, %edi
ja 0x2b5a3
movl %edi, %eax
leaq 0x26439(%rip), %rcx # 0x519d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x26354(%rip), %rax # 0x518fe
retq
| /Tigermouthbear[P]flappytiger/external/glfw/src/egl_context.c |
makeContextCurrentEGL | static void makeContextCurrentEGL(_GLFWwindow* window)
{
if (window)
{
if (!eglMakeCurrent(_glfw.egl.display,
window->context.egl.surface,
window->context.egl.surface,
window->context.egl.handle))
{
_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2eb7d(%rip), %r14 # 0x5aa10
movq 0x20f88(%r14), %rdi
movq 0x21010(%r14), %rax
testq %rbx, %rbx
je 0x2bed4
movq 0x288(%rbx), %rcx
movq 0x290(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x2bee0
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b587
... | /Tigermouthbear[P]flappytiger/external/glfw/src/egl_context.c |
destroyContextOSMesa | static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window-... | pushq %rbx
movq %rdi, %rbx
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x2c6c7
leaq 0x2e35a(%rip), %rax # 0x5aa10
callq *0x21050(%rax)
movq $0x0, 0x2a0(%rbx)
movq 0x2b0(%rbx), %rdi
testq %rdi, %rdi
je 0x2c6e3
callq 0x143c0
movq $0x0, 0x2a8(%rbx)
popq %rbx
retq
| /Tigermouthbear[P]flappytiger/external/glfw/src/osmesa_context.c |
main | int main(int argC, char* argV[])
{
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch)
{
std::cerr << "Error during initialization! Message:\n"
<< StrX(toCatch.getMessage()) << std::endl;
return 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq 0x4bc6(%rip), %rdi # 0x6fc0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2180
cmpl $0x2, %ebx
jl 0x25d7
movl %ebx, %r12d
movl $0x2, %ebp
movl $0x1, %r15d
movl $0x0, 0xc(%rsp)
movq 0x4b... | /apache[P]xerces-c/samples/src/MemParse/MemParse.cpp |
operator<<(std::ostream&, StrX const&) | inline std::ostream& operator<<(std::ostream& target, const StrX& toDump)
{
target << toDump.localForm();
return target;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x2aea
movq %r14, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x2b01
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq %... | /apache[P]xerces-c/samples/src/MemParse/MemParse.hpp |
MemParseHandlers::error(xercesc_4_0::SAXParseException const&) | void MemParseHandlers::error(const SAXParseException& e)
{
std::cerr << "\nError at (file " << StrX(e.getSystemId())
<< ", line " << e.getLineNumber()
<< ", char " << e.getColumnNumber()
<< "): " << StrX(e.getMessage()) << std::endl;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x43d3(%rip), %r14 # 0x6ff0
leaq 0x1959(%rip), %rsi # 0x457d
movl $0x10, %edx
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2110
movq 0x43a0(%rip), %r12 # 0x6fe0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x20e0
movq %r... | /apache[P]xerces-c/samples/src/MemParse/MemParseHandlers.cpp |
MemParseHandlers::warning(xercesc_4_0::SAXParseException const&) | void MemParseHandlers::warning(const SAXParseException& e)
{
std::cerr << "\nWarning at (file " << StrX(e.getSystemId())
<< ", line " << e.getLineNumber()
<< ", char " << e.getColumnNumber()
<< "): " << StrX(e.getMessage()) << std::endl;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x405b(%rip), %r14 # 0x6ff0
leaq 0x161d(%rip), %rsi # 0x45b9
movl $0x12, %edx
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2110
movq 0x4028(%rip), %r12 # 0x6fe0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x20e0
movq %r... | /apache[P]xerces-c/samples/src/MemParse/MemParseHandlers.cpp |
nsync::nsync_time_sleep(timespec) | nsync_time nsync_time_sleep (nsync_time delay) {
nsync_time start = nsync_time_now ();
nsync_time expected_end = nsync_time_add (start, delay);
nsync_time remain;
std::chrono::nanoseconds delay_ns(NSYNC_TIME_NSEC (delay) +
NSYNC_NS_IN_S_ * (int64_t) NSYNC_TIME_SEC (delay));
std::this_thread::sleep_for (dela... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xc8e0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax,... | /google[P]nsync/build_O0/cpp/platform/c++11/src/time_rep_timespec.cc |
Omega_h::find_unique(Omega_h::Read<int>, Omega_h_Family, int, int) | LOs find_unique(LOs const hv2v, Omega_h_Family const family, Int const high_dim,
Int const low_dim) {
OMEGA_H_TIME_FUNCTION;
OMEGA_H_CHECK(high_dim > low_dim);
OMEGA_H_CHECK(low_dim <= 2);
OMEGA_H_CHECK(hv2v.size() % element_degree(family, high_dim, VERT) == 0);
auto const uv2v = form_uses(hv2v, family, h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x171952(%rip), %rsi # 0x277797
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xef870
leaq 0x17143a(%rip), %rdx # 0x277295
le... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::sort_by_high_index(Omega_h::Read<int>, Omega_h::Write<int>, Omega_h::Write<signed char>) | void sort_by_high_index(
LOs const l2lh, Write<LO> const lh2h, Write<I8> const codes) {
OMEGA_H_TIME_FUNCTION;
LO const nl = l2lh.size() - 1;
auto f = OMEGA_H_LAMBDA(LO const l) {
LO const begin = l2lh[l];
LO const end = l2lh[l + 1];
for (LO j = begin; j < end; ++j) {
LO k_min = j;
GO ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x170827(%rip), %rsi # 0x277797
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0xef870
leaq 0x17030c(%rip), %rdx # 0x277295
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xed920
leaq... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::separate_upward_with_codes(int, Omega_h::Read<int>, int, Omega_h::Write<int>, Omega_h::Read<signed char>, Omega_h::Write<signed char>) | void separate_upward_with_codes(LO const nlh, LOs const lh2hl,
Int const nlows_per_high, Write<LO> const lh2h, Bytes const down_codes,
Write<Byte> const codes) {
OMEGA_H_TIME_FUNCTION;
auto f = OMEGA_H_LAMBDA(LO lh) {
LO const hl = lh2hl[lh];
LO const h = hl / nlows_per_high;
lh2h[lh] = h;
I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %ebx
leaq 0x17047c(%rip), %rsi # 0x277797
leaq 0x70(%rsp), %rdi
leaq 0xd8(%rsp), %rdx
callq 0xef870
leaq 0x16ff61(%rip), %rdx # 0x277295
leaq ... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::filter_parents(Omega_h::Parents, int) | Bytes filter_parents(Parents const c2p, Int const parent_dim) {
OMEGA_H_TIME_FUNCTION;
Write<Byte> filter(c2p.parent_idx.size());
auto f = OMEGA_H_LAMBDA(LO c) {
auto const code = c2p.codes[c];
if (amr::code_parent_dim(code) == parent_dim)
filter[c] = 1;
else
filter[c] = 0;
};
parallel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16f416(%rip), %rsi # 0x277797
leaq 0x88(%rsp), %rdi
leaq 0xe0(%rsp), %rdx
callq 0xef870
leaq 0x16eef8(%rip), %rdx # 0x277295
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical<int>(int, Omega_h::Read<int>) | Read<I8> get_codes_to_canonical(Int const deg, Read<T> const ev2v) {
OMEGA_H_TIME_FUNCTION;
if (deg == 4) return get_codes_to_canonical_deg<4>(ev2v);
if (deg == 3) return get_codes_to_canonical_deg<3>(ev2v);
if (deg == 2) return get_codes_to_canonical_deg<2>(ev2v);
OMEGA_H_NORETURN(Read<I8>());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x16b57d(%rip), %rsi # 0x277797
leaq 0x58(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x16b065(%rip), %rdx # 0x277295
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xed920
leaq 0x38(%rsp),... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<3, int>(Omega_h::Read<int>) | Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10c503
movq (%rdi), %rdi
jmp 0x10c507
shrq $0x3, %rdi
shrq $0x2, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x170f9b(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<2, int>(Omega_h::Read<int>) | Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10c626
movq (%rdi), %rdi
jmp 0x10c62a
shrq $0x3, %rdi
shrq $0x2, %rdi
pushq $0x2
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x170e78(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
void Omega_h::find_matches_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool) | void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x16add0(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x16a8b8(%rip),... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
void Omega_h::find_matches_deg<4, int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool) | void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x16a4f6(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x169fde(%rip),... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical<long>(int, Omega_h::Read<long>) | Read<I8> get_codes_to_canonical(Int const deg, Read<T> const ev2v) {
OMEGA_H_TIME_FUNCTION;
if (deg == 4) return get_codes_to_canonical_deg<4>(ev2v);
if (deg == 3) return get_codes_to_canonical_deg<3>(ev2v);
if (deg == 2) return get_codes_to_canonical_deg<2>(ev2v);
OMEGA_H_NORETURN(Read<I8>());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x16a0be(%rip), %rsi # 0x277797
leaq 0x58(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x169ba6(%rip), %rdx # 0x277295
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xed920
leaq 0x38(%rsp),... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<4, long>(Omega_h::Read<long>) | Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10d89f
movq (%rdi), %rdi
jmp 0x10d8a3
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x4
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x16fbff(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<3, long>(Omega_h::Read<long>) | Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10d9c2
movq (%rdi), %rdi
jmp 0x10d9c6
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x16fadc(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
void Omega_h::find_matches_deg<2, long>(Omega_h::Read<int>, Omega_h::Read<long>, Omega_h::Read<long>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool) | void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x169911(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x1693f9(%rip),... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
void Omega_h::find_matches_deg<3, long>(Omega_h::Read<int>, Omega_h::Read<long>, Omega_h::Read<long>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool) | void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x1694cb(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x168fb3(%rip),... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Write<int>::~Write() | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x10eb45
decl 0x30(%rbx)
je 0x10eb47
popq %rbx
retq
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf6cf0
nop
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Write<int>::Write(Omega_h::Write<int> const&) | OMEGA_H_INLINE void copy(SharedAlloc const& other) noexcept {
alloc = other.alloc;
#ifndef __CUDA_ARCH__
if (alloc && (!(reinterpret_cast<std::uintptr_t>(alloc) & FREE_MASK))) {
// allocated
if (entering_parallel) {
alloc = reinterpret_cast<Alloc*>(
(std::uintptr_t(alloc->size) <... | movq (%rsi), %rax
movq %rax, (%rdi)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x10eb90
movq 0x203148(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x10eb8d
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rdi)
jmp 0x10eb90
incl 0x30(%rax)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
retq... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Write<signed char>::~Write() | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x10ebf1
decl 0x30(%rbx)
je 0x10ebf3
popq %rbx
retq
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf6cf0
nop
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Adj::Adj(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>) | Adj(LOs a2ab_, LOs ab2b_, Read<I8> codes_)
: Graph(a2ab_, ab2b_), codes(codes_) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf0580
movq %rsp, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xf6db0
movq %rsp, %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0... | /gahansen[P]omega_h/src/Omega_h_adj.hpp |
Omega_h::Write<signed char>::Write(Omega_h::Write<signed char>&&) | OMEGA_H_INLINE void move(SharedAlloc&& other) noexcept {
alloc = other.alloc;
direct_ptr = other.direct_ptr;
#ifndef __CUDA_ARCH__
if (alloc && (!(reinterpret_cast<std::uintptr_t>(alloc) & FREE_MASK))) {
// allocated
if (entering_parallel) {
--(alloc->use_count);
alloc = reinterp... | movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x10ecd0
movq 0x203006(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x10ecd0
decl 0x30(%rax)
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Write<int>::Write(Omega_h::Write<int>&&) | OMEGA_H_INLINE void move(SharedAlloc&& other) noexcept {
alloc = other.alloc;
direct_ptr = other.direct_ptr;
#ifndef __CUDA_ARCH__
if (alloc && (!(reinterpret_cast<std::uintptr_t>(alloc) & FREE_MASK))) {
// allocated
if (entering_parallel) {
--(alloc->use_count);
alloc = reinterp... | movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x10ed5e
movq 0x202f78(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x10ed5e
decl 0x30(%rax)
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Children::Children(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>) | Children(LOs a2ab_, LOs ab2b_, Read<I8> codes_)
: Graph(a2ab_, ab2b_), codes(codes_) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf0580
movq %rsp, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xf6db0
movq %rsp, %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0... | /gahansen[P]omega_h/src/Omega_h_adj.hpp |
Omega_h::Adj::Adj(Omega_h::Read<int>, Omega_h::Read<signed char>) | Adj(LOs ab2b_, Read<I8> codes_) : Graph(ab2b_), codes(codes_) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0xf0580
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfecc0
movq %rsp, %rdi
callq 0xff620
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xf8e10
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %... | /gahansen[P]omega_h/src/Omega_h_adj.hpp |
Omega_h::elements_across_sides_count_functor::elements_across_sides_count_functor(int, Omega_h::Read<int> const&, Omega_h::Read<signed char> const&, Omega_h::Write<int> const&) | elements_across_sides_count_functor(
Int nsides_per_elem_arg,
Read<LO> const& elem_side2side_arg,
Read<I8> const& side_is_exposed_arg,
Write<LO> const& degrees_arg
)
:nsides_per_elem(nsides_per_elem_arg)
,elem_side2side(elem_side2side_arg)
,side_is_exposed(side_is_exposed_arg)
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdi, %r12
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf0580
leaq 0x18(%r12), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xf8e10
addq $0x28, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xf0580
po... | /gahansen[P]omega_h/src/Omega_h_adj.cpp |
Omega_h::Write<long>::~Write() | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x10f393
decl 0x30(%rbx)
je 0x10f395
popq %rbx
retq
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf6cf0
nop
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Read<long> Omega_h::align_ev2v_deg<2, long>(Omega_h::Read<long>, Omega_h::Read<signed char>) | Read<T> align_ev2v_deg(Read<T> ev2v, Read<I8> codes) {
OMEGA_H_CHECK(ev2v.size() == codes.size() * deg);
auto ne = codes.size();
Write<T> ev2v_w(ev2v.size());
auto f = OMEGA_H_LAMBDA(LO e) {
align_adj<deg>(codes[e], ev2v, e * deg, ev2v_w, e * deg);
};
parallel_for(ne, f, "align_ev2v");
return ev2v_w;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r13
testb $0x1, %r13b
jne 0x1126d0
movq (%r13), %rax
jmp 0x1126d7
movq %r13, %rax
shrq $0x3, %rax
shrq $0x3, %rax
movq (%r12), %r14
testb $0x1, %r14b
jne 0x1126f5
movl (%r14), %r14d
leal... | /gahansen[P]omega_h/src/Omega_h_align.cpp |
void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::align_ev2v_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<signed char>)::'lambda'(int)>(int, Omega_h::Read<int> Omega_h::align_ev2v_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<signed char>)::'lambda'(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 %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf89c0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf2220
leaq 0x8(%rsp), %rdi
callq 0xf1db0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf1db0
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<int> Omega_h::align_ev2v_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<signed char>)::'lambda'(int)::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
} | movslq %esi, %rax
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rcx
movzbl (%rdx,%rax), %edx
addl %eax, %eax
movslq %eax, %rsi
shrl %edx
shlq $0x2, %rsi
addq 0x18(%rdi), %rsi
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x112e0b
leal (%rdx,%rdi), %r8d
andl $0x1, %r8d
movl (%rsi,%rdi,4), %r9d
orl %eax, %r8d
movslq %r8d, %r8
movl %r9d, (... | /gahansen[P]omega_h/src/Omega_h_array.hpp |
void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::align_ev2v_deg<4, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)::'lambda'(int)>(int, Omega_h::Read<long> Omega_h::align_ev2v_deg<4, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)::'lambda'(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 %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x100730
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf1f70
leaq 0x8(%rsp), %rdi
callq 0xf0c80
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf0c80
movq %rbx, %rdi
callq 0... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<long> Omega_h::align_ev2v_deg<4, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)::'lambda'(int)::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
} | movslq %esi, %rcx
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rax
movzbl (%rdx,%rcx), %edx
shll $0x2, %ecx
movslq %ecx, %rsi
movl %edx, %r8d
shrl %r8d
shlq $0x3, %rsi
addq 0x18(%rdi), %rsi
xorl %edi, %edi
cmpq $0x4, %rdi
je 0x113018
leal (%r8,%rdi), %r9d
andl $0x3, %r9d
movq (%rsi,%rdi,8), %r10
orl %ecx, %r9d
movslq %r9d, %... | /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Write<signed char>::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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x15a998(%rip), %rdi # 0x27896d
xorl %esi, %esi
callq 0xf9c20
movslq %ebp, %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0xf8970
movq (%rbx), %r14
testq %r14, %r14
sete %al
test... | /gahansen[P]omega_h/src/Omega_h_array.cpp |
void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char) | 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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movb %bl, 0x10(%r15)
movq (%r14), %rdi
testb $0x1, %dil
jne 0x11e127
movq (%rdi), %rdi
jmp 0x11e12b
shrq $0x3, %rdi
leaq 0x15a8a2(%rip), %rdx # 0x2789d4
leaq 0x8(%rsp),... | /gahansen[P]omega_h/src/Omega_h_array.cpp |
void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char) | 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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movb %bpl, 0x10(%r15)
movb %bl, 0x11(%r15)
movq (%r14), %rdi
testb $0x1, %dil
jne 0x11e1ff
movq (%rdi), %rdi
jmp 0x11e203
shrq $0x3, %rdi
leaq 0x15a7... | /gahansen[P]omega_h/src/Omega_h_array.cpp |
Omega_h::Write<signed char>::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
} | movslq %esi, %rax
addq 0x8(%rdi), %rax
retq
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Write<signed char>::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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x15a612(%rip), %rdi # 0x278994
xorl %esi, %esi
callq 0xf9c20
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movb (%rax,%rcx), %bl
leaq 0x7(%rsp), %rdi
callq 0xf7d50
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /gahansen[P]omega_h/src/Omega_h_array.cpp |
Omega_h::Read<signed char>::Read(std::initializer_list<signed char>, 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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xf89e0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xfe060
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xf9e00
addq $0x28, %rsp
popq %rbx
popq %r14
ret... | /gahansen[P]omega_h/src/Omega_h_array.cpp |
Omega_h::Read<signed char>::size() const | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rax
testb $0x1, %al
jne 0x11e501
movq (%rax), %rax
retq
shrq $0x3, %rax
retq
| /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Read<signed char>::last() const | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rsi
testb $0x1, %sil
jne 0x11e530
movq (%rsi), %rsi
jmp 0x11e534
shrq $0x3, %rsi
decl %esi
jmp 0x100580
nop
| /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Read<signed char>::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... | cmpq $0x0, 0x8(%rdi)
setne %al
retq
nop
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Read<signed char>::end() const | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testb $0x1, %cl
jne 0x11e573
movq (%rcx), %rcx
jmp 0x11e577
shrq $0x3, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
retq
| /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Write<signed char> Omega_h::deep_copy<signed char>(Omega_h::Read<signed char>, 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 %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15a088(%rip), %rsi # 0x278a0a
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x1588fd(%rip), %rdx # 0x277295
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xed920
leaq 0x50(%rsp), %rdi
movl ... | /gahansen[P]omega_h/src/Omega_h_array.cpp |
Omega_h::Write<int>::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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x159dd6(%rip), %rdi # 0x27896d
xorl %esi, %esi
callq 0xf9c20
movslq %ebp, %rsi
shlq $0x2, %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0xf8970
movq (%rbx), %r14
testq %r14, %r... | /gahansen[P]omega_h/src/Omega_h_array.cpp |
Omega_h::Write<int>::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... | cmpq $0x0, 0x8(%rdi)
setne %al
retq
nop
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::Write<int>::end() const | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testb $0x1, %cl
jne 0x11efad
movq (%rcx), %rcx
jmp 0x11efb1
shrq $0x3, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rax
retq
nop
| /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::HostWrite<int>::HostWrite(Omega_h::Write<int>) | 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())]);
... | jmp 0xf0580
nop
| /gahansen[P]omega_h/src/Omega_h_array.cpp |
Omega_h::HostWrite<int>::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
} | movslq %esi, %rax
shlq $0x2, %rax
addq 0x8(%rdi), %rax
retq
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::HostWrite<int>::size() const | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rax
testb $0x1, %al
jne 0x11f214
movq (%rax), %rax
jmp 0x11f218
shrq $0x3, %rax
shrq $0x2, %rax
retq
nop
| /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::HostRead<int>::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
} | movslq %esi, %rax
shlq $0x2, %rax
addq 0x8(%rdi), %rax
retq
| /gahansen[P]omega_h/src/Omega_h_array.hpp |
Omega_h::HostRead<int>::last() const | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rax
testb $0x1, %al
jne 0x11f2c6
movq (%rax), %rax
jmp 0x11f2ca
shrq $0x3, %rax
movq 0x8(%rdi), %rcx
shlq $0x1e, %rax
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
addq %rax, %rdx
sarq $0x20, %rdx
movl (%rcx,%rdx,4), %eax
retq
| /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::divide_each_maybe_zero(Omega_h::Read<double>, Omega_h::Read<double>) | Reals divide_each_maybe_zero(Reals a, Reals b) {
if (b.size() == 0) {
OMEGA_H_CHECK(a.size() == 0);
return a;
}
auto width = divide_no_remainder(a.size(), b.size());
Write<Real> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) {
if (b[i] != 0.0) {
for (Int j = 0; j < width; ++j) {
c[i * wi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
testb $0x1, %sil
jne 0x121c52
movq (%rsi), %rcx
jmp 0x121c59
movq %rsi, %rcx
shrq $0x3, %rcx
movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
movq (%r14), %rdi
testq %r... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::land_each(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | Bytes land_each(Bytes a, Bytes 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, "land_each");
return c;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x122310
movq (%r12), %rax
jmp 0x122317
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x122324
movq (%rcx), %rcx
jmp 0x122328... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::lor_each(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | Bytes lor_each(Bytes a, Bytes 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, "lor_each");
return c;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x1225e2
movq (%r12), %rax
jmp 0x1225e9
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1225f6
movq (%rcx), %rcx
jmp 0x1225fa... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::bit_or_each(Omega_h::Read<signed char>, Omega_h::Read<signed char>) | Bytes bit_or_each(Bytes a, Bytes 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, "bit_or_each");
return c;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x1228b2
movq (%r12), %rax
jmp 0x1228b9
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1228c6
movq (%rcx), %rcx
jmp 0x1228ca... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::bit_neg_each(Omega_h::Read<signed char>) | Bytes bit_neg_each(Bytes a) {
Write<I8> b(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = ~(a[i]); };
parallel_for(a.size(), f, "bit_neg_each");
return b;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testb $0x1, %r15b
jne 0x122b75
movq (%r15), %r15
jmp 0x122b79
shrq $0x3, %r15
leaq 0x15a937(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x18(%r... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::fabs_each(Omega_h::Read<double>) | Read<Real> fabs_each(Read<Real> a) {
Write<Real> b(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = std::abs(a[i]); };
parallel_for(a.size(), f, "fabs_each");
return b;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testb $0x1, %r15b
jne 0x122d68
movq (%r15), %r15
jmp 0x122d6c
shrq $0x3, %r15
leaq 0x15a744(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xef870
shrq $0x3, %r15
leaq 0x8(%rsp), %... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::int128_sum(Omega_h::Read<double>, double) | Int128 int128_sum(Reals const a, double const unit) {
if (a.size() == 0) {
return Int128(0);
}
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = Int128(0);
auto const op = Int128Plus();
auto transform = OMEGA_H_LAMBDA(LO i)->Int128 {
return Int128::from_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movq (%rdi), %r14
testb $0x1, %r14b
jne 0x12306b
movq (%r14), %r14
movq %r14, %rax
shrq $0x3, %rax
testl %eax, %eax
jne 0x12307e
jmp 0x123112
movq %r14, %rax
shrq $0x6, %rax
testl %eax, %eax
je 0x123112
shrq $0x3, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %r... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::repro_sum(Omega_h::Read<double>) | Real repro_sum(Reals a) {
if (a.size() == 0) {
return 0.0;
}
begin_code("repro_sum");
int expo = max_exponent(a);
auto const init = ArithTraits<int>::min();
if (expo == init) return 0.0;
double unit = exp2(double(expo - MANTISSA_BITS));
Int128 fixpt_sum = int128_sum(a, unit);
double ret = fixpt_su... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
testb $0x1, %al
jne 0x123153
movq (%rax), %rax
jmp 0x123157
shrq $0x3, %rax
shrq $0x3, %rax
xorps %xmm0, %xmm0
testl %eax, %eax
je 0x12320c
leaq 0x155b42(%rip), %rdi # 0x278caf
xorl %esi, %esi
callq 0xf9c20
leaq 0x20(%rsp), %r14
movq... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::repro_sum(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>) | Real repro_sum(CommPtr comm, Reals a) {
begin_code("repro_sum(comm)");
auto const init = ArithTraits<int>::min();
auto expo0 = max_exponent(a);
int expo = comm->allreduce(expo0, OMEGA_H_MAX);
if (expo == init) return 0.0;
double unit = exp2(double(expo - MANTISSA_BITS));
Int128 fixpt_sum = int128_sum(a, u... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x155a6e(%rip), %rdi # 0x278cb9
xorl %esi, %esi
callq 0xf9c20
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
movq %r15, %rdi
callq 0xef510
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0xfdc90
movq (%... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::repro_sum(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, int, double*) | void repro_sum(CommPtr comm, Reals a, Int ncomps, Real result[]) {
for (Int comp = 0; comp < ncomps; ++comp) {
result[comp] = repro_sum(comm, get_component(a, ncomps, comp));
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
xorl %r13d, %r13d
testl %edx, %edx
movl $0x0, %r12d
cmovgl %edx, %r12d
leaq 0x18(%rsp), %rbx
leaq 0x28(%rsp), %r14
leaq 0x38(%rsp), %r15
cmpq %r13, %r12
je 0x12... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
Omega_h::interpolate_between(Omega_h::Read<double>, Omega_h::Read<double>, double) | Reals interpolate_between(Reals a, Reals b, Real t) {
OMEGA_H_CHECK(a.size() == b.size());
auto n = a.size();
auto out = Write<Real>(n);
auto f = OMEGA_H_LAMBDA(LO i) { out[i] = a[i] * (1.0 - t) + b[i] * t; };
parallel_for(n, f, "interpolate_between");
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r14
testb $0x1, %r14b
jne 0x12343c
movq (%r14), %rax
jmp 0x123443
movq %r14, %rax
shrq $0x3, %rax
shrq $0x3, %rax
movq (%r15), %rcx
testb $0x1, %cl
jne... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x126554
movq (%r12), %rax
jmp 0x12655b
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x126568
movq (%rcx), %rcx
jmp 0x12656c
shrq $0x3, %rcx
cmpl ... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x126718
movq (%rdi), %rdi
jmp 0x12671c
shrq $0x3, %rdi
movl %r14d, %esi
callq 0xfd130
movl %eax, %r12d
leaq 0x156d89(%rip), %rsi # 0x27d4b7
... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x126998
movq (%rbx), %rbx
jmp 0x12699c
shrq $0x3, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf8e10
movb %bpl, 0x10(%r14)
pushq $-0x1
popq %rdx
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rcx
c... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, 0x28(%rsp)
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
je 0x126b7e
movq %rcx, %rbp
subq %rax, %rbp
shrq $0x4, %rbp
movq (%rax), %r15
testb $0x1, %r15b
jne 0x126b89
movq (%r15), %r15
jmp 0x126b8d
xorp... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
je 0x126f1f
subq %rax, %rsi
sarq $0x4, %rsi
incq %rsi
leaq 0x60(%rsp), %rbx
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0xee7f0
movq (%rbx), %rax
test... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x12708a
movq (%rbx), %rax
jmp 0x127091
movq %rbx, %rax
shrq $0x3, %rax
shrq $0x2, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1270a2
movq (%rcx), %rcx
jmp 0x1270a6
shrq $0x3, %rcx
shrq $0x2, %rcx
cmpl %ecx, %e... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0x1eab65(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xff3b0
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
movslq %r14d, %rdx... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
Omega_h::Promoted<int>::type Omega_h::get_sum<int>(Omega_h::Read<int>) | const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__... | movq (%rdi), %rax
testb $0x1, %al
jne 0x1271d4
movq (%rax), %rax
jmp 0x1271d8
shrq $0x3, %rax
movq 0x8(%rdi), %rcx
shrq $0x2, %rax
movslq %eax, %rdx
movq 0x1eaad6(%rip), %rax # 0x311cc0
movb $0x0, (%rax)
shlq $0x2, %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x127203
addl (%rcx,%rsi), %eax
addq $0x4, %rs... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x12721b
movq (%rbx), %rbx
jmp 0x12721f
shrq $0x3, %rbx
shrq $0x2, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
xorl %edi, %edi
movl %ebx, %esi
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
movq %r14, %rcx
callq 0x... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0x1eaa3a(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xf4160
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movslq %r14d, %rcx
movslq %ebp, %rdx
cmp... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x1272e8
movq (%rbx), %rbx
jmp 0x1272ec
shrq $0x3, %rbx
shrq $0x2, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
xorl %edi, %edi
movl %ebx, %esi
movl $0x80000000, %edx # imm = 0x80000000
movq %r14, %rcx
callq 0x... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0x1ea96d(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xf4160
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movslq %r14d, %rcx
movslq %ebp, %rdx
cmp... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
testb $0x1, %sil
jne 0x1275a1
movq (%rsi), %rsi
jmp 0x1275a5
shrq $0x3, %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0xedf20
movq (%r14), %rsi
testb $0x1, %sil
jne 0x12... | /gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::neq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int)>(int, int, Omega_h::Read<signed char> Omega_h::neq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x13528d
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1dca7f(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1015e0
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x13527d
movq 0x8(%rsp), %rdx
m... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::get_component<int>(Omega_h::Read<int>, int, int)::'lambda'(int)>(int, int, Omega_h::Read<int> Omega_h::get_component<int>(Omega_h::Read<int>, int, int)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1353ab
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x1dc980(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xfaac0
movb $0x0, (%r15)
movq 0x18(%r14), %rax
movslq %ebx, %rcx
movslq %ebp, %rdx
su... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int)::'lambda'(int)>(int, int, void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1354b6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x1dc875(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf0ed0
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movslq %ebp, %rdx
sub... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::interleave<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>)::'lambda'(int)>(int, int, Omega_h::Read<int> Omega_h::interleave<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1355e2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x1dc749(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xee100
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movslq %ebp, %rdx
sub... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::min_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::min_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x135f06
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1dbe15(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xfca90
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x28(%r... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::max_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::max_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x136028
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1dbcf3(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf7300
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x28(%r... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::ternary_each<long>(Omega_h::Read<signed char>, Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::ternary_each<long>(Omega_h::Read<signed char>, Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(i... | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x136184
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movl %edi, %r14d
movq 0x1dbba3(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf3e90
movb $0x0, (%r15)
movl 0x20(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0x18(%rsp),... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_geq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(long, long, Omega_h::Read<signed char> Omega_h::each_geq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x136568
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1db7a6(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf72e0
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x136556
movq 0x10(%rsp), %... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_leq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(long, long, Omega_h::Read<signed char> Omega_h::each_leq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x13664e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1db6c0(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf3350
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x13663c
movq 0x10(%rsp), %... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
Omega_h::base64::(anonymous namespace)::decode_4(char const*, unsigned char*, unsigned long) | void decode_4(char const* in, unsigned char* out, std::size_t nout = 3) {
unsigned char val[4];
for (unsigned i = 0; i < 4; ++i) {
val[i] = char_to_value[U(in[i])];
OMEGA_H_CHECK(val[i] < 64);
}
/* cast it all !
* (technically this should all be run as
* unsigned char, but apparently it gets push... | pushq %rax
xorl %eax, %eax
leaq 0x13dd0e(%rip), %rcx # 0x278e20
cmpq $0x4, %rax
je 0x13b151
movsbq (%rdi,%rax), %r8
movl %r8d, %r8d
movb (%r8,%rcx), %r8b
movb %r8b, 0x4(%rsp,%rax)
incq %rax
cmpb $0x40, %r8b
jb 0x13b112
leaq 0x13bf4f(%rip), %rdi # 0x277088
leaq 0x13de20(%rip), %rsi # 0x278f60
leaq 0x13de25(%rip... | /gahansen[P]omega_h/src/Omega_h_base64.cpp |
Omega_h::base64::read_encoded[abi:cxx11](std::istream&) | std::string read_encoded(std::istream& f) {
std::string out;
while (true) {
int c = f.get();
if (c < 0 || c > 127) break;
unsigned char val = char_to_value[c];
if (val > 63) break;
out.push_back(static_cast<char>(c));
}
return out;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x13dc5e(%rip), %r15 # 0x278e20
movq %r14, %rdi
callq 0xf8c00
cmpl $0x7f, %eax
ja 0x13b1e5
movl %eax, %ecx
cmpb $0x3f, (%rcx,%r15)
ja 0x13b1e5
movsbl %al, %esi
movq... | /gahansen[P]omega_h/src/Omega_h_base64.cpp |
Omega_h::BBox<1> Omega_h::find_bounding_box<1>(Omega_h::Read<double>) | BBox<dim> find_bounding_box(Reals coords) {
auto npts = divide_no_remainder(coords.size(), dim);
BBox<dim> init;
for (Int i = 0; i < dim; ++i) {
init.min[i] = ArithTraits<Real>::max();
init.max[i] = ArithTraits<Real>::min();
}
return transform_reduce(IntIterator(0), IntIterator(npts), init,
Unit... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x13b21b
movq (%rbx), %rbx
jmp 0x13b21f
shrq $0x3, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xf3e40
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
shrq $0x3, %rbx
movsd 0x13d86b(%rip), %xmm0 # 0x278ab0
movsd 0x13... | /gahansen[P]omega_h/src/Omega_h_bbox.cpp |
Omega_h::BBox<1> Omega_h::transform_reduce<Omega_h::IntIterator, Omega_h::GetBBoxOp<1>, Omega_h::BBox<1>, Omega_h::UniteOp<1>>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::BBox<1>, Omega_h::UniteOp<1>, Omega_h::GetBBoxOp<1>&&) | 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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movl %edi, %ebp
movq 0x1d69ec(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xfbcb0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movb $0... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
Omega_h::BBox<2> Omega_h::find_bounding_box<2>(Omega_h::Read<double>) | BBox<dim> find_bounding_box(Reals coords) {
auto npts = divide_no_remainder(coords.size(), dim);
BBox<dim> init;
for (Int i = 0; i < dim; ++i) {
init.min[i] = ArithTraits<Real>::max();
init.max[i] = ArithTraits<Real>::min();
}
return transform_reduce(IntIterator(0), IntIterator(npts), init,
Unit... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x13b373
movq (%rdi), %rdi
jmp 0x13b377
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x2
popq %rsi
callq 0xfd130
movl %eax, %ebp
pushq $0x2
popq %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x... | /gahansen[P]omega_h/src/Omega_h_bbox.cpp |
Omega_h::BBox<2> Omega_h::transform_reduce<Omega_h::IntIterator, Omega_h::GetBBoxOp<2>, Omega_h::BBox<2>, Omega_h::UniteOp<2>>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::BBox<2>, Omega_h::UniteOp<2>, Omega_h::GetBBoxOp<2>&&) | 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xb0(%rsp), %r12
movq 0x1d684c(%rip), %r13 # 0x311cc0
movb $0x1, (%r13)
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xfbcb0
movb $0x0, (%r13)
movslq %r14d, %rax
mov... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
Omega_h::BBox<3> Omega_h::find_bounding_box<3>(Omega_h::Read<double>) | BBox<dim> find_bounding_box(Reals coords) {
auto npts = divide_no_remainder(coords.size(), dim);
BBox<dim> init;
for (Int i = 0; i < dim; ++i) {
init.min[i] = ArithTraits<Real>::max();
init.max[i] = ArithTraits<Real>::min();
}
return transform_reduce(IntIterator(0), IntIterator(npts), init,
Unit... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x13b589
movq (%rdi), %rdi
jmp 0x13b58d
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
xorl %eax, %eax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFF... | /gahansen[P]omega_h/src/Omega_h_bbox.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.