name string | code string | asm string | file string |
|---|---|---|---|
Omega_h::BBox<3> Omega_h::transform_reduce<Omega_h::IntIterator, Omega_h::GetBBoxOp<3>, Omega_h::BBox<3>, Omega_h::UniteOp<3>>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::BBox<3>, Omega_h::UniteOp<3>, Omega_h::GetBBoxOp<3>&&) | 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 $0xd8, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x110(%rsp), %r12
movq 0x1d6611(%rip), %r13 # 0x311cc0
movb $0x1, (%r13)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xfbcb0
movb $0x0, (%r13)
leaq 0x48(%rsp), %rax... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
Omega_h::BBox<1> Omega_h::get_bounding_box<1>(Omega_h::Mesh*) | BBox<dim> get_bounding_box(Mesh* mesh) {
auto bb = find_bounding_box<dim>(mesh->coords());
for (Int i = 0; i < dim; ++i) {
bb.min[i] = mesh->comm()->allreduce(bb.min[i], OMEGA_H_MIN);
bb.max[i] = mesh->comm()->allreduce(bb.max[i], OMEGA_H_MAX);
}
return bb;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xffe20
movq %r14, %rdi
callq 0xef430
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xfdc90
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeef10
movq (%r14), %rd... | /gahansen[P]omega_h/src/Omega_h_bbox.cpp |
std::vector<int, std::allocator<int>>::const_reference Omega_h::at<int>(std::vector<int, std::allocator<int>> const&, int) | inline typename std::vector<T>::const_reference at(
std::vector<T> const& v, int i) {
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < int(v.size()));
return v[std::size_t(i)];
} | pushq %rax
testl %esi, %esi
js 0x147263
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x14727c
movl %esi, %ecx
leaq (%rax,%rcx,4), %rax
popq %rcx
retq
leaq 0x12fe1e(%rip), %rdi # 0x277088
leaq 0x1323c4(%rip), %rsi # 0x279635
leaq 0x1323c4(%rip), %rdx # 0x27963c
push... | /gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
bool Omega_h::intersects<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&) | bool intersects(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) {
auto it = a.find(x);
if (it != a.end()) return true;
}
return false;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x8(%rdi), %r12
cmpq %rbx, %r15
je 0x148b82
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xfdbe0
cmpq %r12, %rax
jne 0x148b82
movq %r15, %rdi
callq 0xf86e0
movq %rax, %r15
jmp 0x148b5f
cmpq %... | /gahansen[P]omega_h/src/Omega_h_set.hpp |
std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::const_reference Omega_h::at<std::set<int, std::less<int>, std::allocator<int>>>(std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>... | inline typename std::vector<T>::const_reference at(
std::vector<T> const& v, int i) {
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < int(v.size()));
return v[std::size_t(i)];
} | pushq %rax
testl %esi, %esi
js 0x148cb1
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x30
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x148cca
movl %esi, %eax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
popq %rcx
retq
leaq 0x12e3d0(%rip), %rdi # 0x277088
leaq 0x130976(%rip), %rsi # ... | /gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
void Omega_h::unite_with<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&) | void unite_with(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) a.insert(x);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x148d1a
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xf7390
movq %r15, %rdi
callq 0xf86e0
movq %rax, %r15
jmp 0x148cfc
popq %rbx
popq %r14
popq %r15
retq
| /gahansen[P]omega_h/src/Omega_h_set.hpp |
void Omega_h::subtract_from<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&) | void subtract_from(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) {
auto it = a.find(x);
if (it == a.end()) continue;
a.erase(it);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x8(%rdi), %r12
cmpq %rbx, %r15
je 0x148f2b
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xfdbe0
cmpq %r12, %rax
je 0x148f1e
movq %r14, %rdi
movq %rax, %rsi
callq 0xecb70
movq %r15, %rdi
call... | /gahansen[P]omega_h/src/Omega_h_set.hpp |
Omega_h::check_collapse_class(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>) | Read<I8> check_collapse_class(
Mesh* mesh, LOs cands2edges, Read<I8> cand_codes) {
auto ncands = cands2edges.size();
auto verts2class_dim = mesh->get_array<I8>(VERT, "class_dim");
auto edges2class_dim = mesh->get_array<I8>(EDGE, "class_dim");
auto edge_verts2verts = mesh->ask_verts_of(EDGE);
auto cand_cod... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x78(%rsp)
movq (%rdx), %r14
testb $0x1, %r14b
jne 0x149ce5
movq (%r14), %r14
jmp 0x149ce9
shrq $0x3, %r14
leaq 0x135c0d(%rip), %rsi # 0x27f8fd
leaq ... | /gahansen[P]omega_h/src/Omega_h_check_collapse.cpp |
Omega_h::check_collapse_exposure(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>, int) | Read<I8> check_collapse_exposure(
Mesh* mesh, LOs cands2edges, Read<I8> cand_codes, Int cell_dim) {
auto e2c = mesh->ask_up(EDGE, cell_dim);
auto e2ec = e2c.a2ab;
auto ec2c = e2c.ab2b;
auto ec_codes = e2c.codes;
auto cs2s = mesh->ask_down(cell_dim, cell_dim - 1).ab2b;
auto nccs = simplex_degree(cell_dim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movl %r8d, %r15d
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x298(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %r8d, %ecx
callq 0xf2f20
leaq 0x148(%rsp), %rdi
movq %r14, %rsi
c... | /gahansen[P]omega_h/src/Omega_h_check_collapse.cpp |
Omega_h::check_collapse_exposure(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>) | Read<I8> check_collapse_exposure(
Mesh* mesh, LOs cands2edges, Read<I8> cand_codes) {
OMEGA_H_CHECK(mesh->parting() == OMEGA_H_GHOSTED);
for (Int cell_dim = Int(EDGE) + 1; cell_dim <= mesh->dim(); ++cell_dim) {
cand_codes =
check_collapse_exposure(mesh, cands2edges, cand_codes, cell_dim);
}
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0xf9e70
cmpl $0x1, %eax
jne 0x14ae90
pushq $0x2
popq %rbp
leaq 0x48(%rsp), %r13
leaq 0x38(%rsp), %rbx
leaq 0x58(%rsp), %r15
movq %r14, %rdi
... | /gahansen[P]omega_h/src/Omega_h_check_collapse.cpp |
Omega_h::classify_sides_by_exposure(Omega_h::Mesh*, Omega_h::Read<signed char>) | void classify_sides_by_exposure(Mesh* mesh, Read<I8> side_is_exposed) {
auto dim = mesh->dim();
auto ns = mesh->nents(dim - 1);
Write<I8> class_dim(ns);
auto f = OMEGA_H_LAMBDA(LO s) {
class_dim[s] = static_cast<I8>(dim - side_is_exposed[s]);
};
parallel_for(ns, f, "classify_sides_by_exposure");
mesh-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %r12d
leal -0x1(%r12), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf0100
movl %eax, %r14d
leaq 0x13257f(%rip), %rsi # 0x27d4b7
movq %rsp, %rdi
leaq 0x58(%rsp), %rdx
callq 0xef8... | /gahansen[P]omega_h/src/Omega_h_class.cpp |
Omega_h::classify_hinges_by_sharpness(Omega_h::Mesh*, Omega_h::Read<signed char>, Omega_h::Read<signed char>) | void classify_hinges_by_sharpness(
Mesh* mesh, Read<I8> hinge_is_exposed, Read<I8> hinge_is_sharp) {
auto dim = mesh->dim();
auto nh = mesh->nents(dim - 2);
Write<I8> class_dim(nh);
auto f = OMEGA_H_LAMBDA(LO h) {
class_dim[h] =
static_cast<I8>(dim - hinge_is_exposed[h] - hinge_is_sharp[h]);
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %r13d
leal -0x2(%r13), %esi
movq %rbx, %rdi
movl %esi, 0xc(%rsp)
callq 0xf0100
movl %eax, %r14d
leaq 0x132313(%rip), %rsi # 0x27d4b7
leaq 0x20(%rsp), %rdi
leaq 0... | /gahansen[P]omega_h/src/Omega_h_class.cpp |
Omega_h::classify_elements(Omega_h::Mesh*) | void classify_elements(Mesh* mesh) {
mesh->add_tag<I8>(mesh->dim(), "class_dim", 1,
Read<I8>(mesh->nelems(), static_cast<I8>(mesh->dim())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %ebp
leaq 0x134479(%rip), %rsi # 0x27f8fd
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
movq %rbx, %rdi
callq 0xff990
movl %eax, %r14d
movq %rbx, %rdi
callq 0xfe5f0
movl %eax, %r15d
leaq 0x132007(%rip), %... | /gahansen[P]omega_h/src/Omega_h_class.cpp |
Omega_h::classify_by_angles(Omega_h::Mesh*, double) | void classify_by_angles(Mesh* mesh, Real sharp_angle) {
OMEGA_H_CHECK(mesh->family() == OMEGA_H_SIMPLEX);
auto dim = mesh->dim();
classify_elements(mesh);
auto side_is_exposed = mark_exposed_sides(mesh);
classify_sides_by_exposure(mesh, side_is_exposed);
if (dim == 1) return;
auto hinge_is_exposed = mark_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movsd %xmm0, 0x58(%rsp)
cmpl $0x0, (%rdi)
jne 0x14ba17
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %r12d
movq %rbx, %rdi
callq 0xf91a0
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x101770
leaq 0x140... | /gahansen[P]omega_h/src/Omega_h_class.cpp |
Omega_h::project_classification(Omega_h::Mesh*, int, Omega_h::Write<signed char>, Omega_h::Write<int>, bool) | void project_classification(Mesh* mesh, Int ent_dim, Write<I8> class_dim,
Write<ClassId> class_id, bool relaxed) {
auto l2h = mesh->ask_up(ent_dim, ent_dim + 1);
auto l2lh = l2h.a2ab;
auto lh2h = l2h.ab2b;
auto high_class_dim = mesh->get_array<I8>(ent_dim + 1, "class_dim");
auto high_class_id = mesh->get_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %r8d, 0xc(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %r13d
leaq 0x188(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %r13d, %ecx
callq 0xf2f20
le... | /gahansen[P]omega_h/src/Omega_h_class.cpp |
Omega_h::classify_equal_order(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>) | void classify_equal_order(
Mesh* mesh, Int ent_dim, LOs eqv2v, Read<ClassId> eq_class_ids) {
LOs eq2e;
if (ent_dim == mesh->dim()) {
/* assuming elements were constructed in the same order ! */
eq2e = LOs(mesh->nelems(), 0, 1);
} else if (ent_dim == VERT) {
eq2e = eqv2v;
} else {
Write<LO> e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
callq 0xfe5f0
cmpl %ebx, %eax
jne 0x14cc78
movq %r14, %rdi
callq 0xff990
movl %eax, %ebp
leaq 0x13088c(%rip), %rsi... | /gahansen[P]omega_h/src/Omega_h_class.cpp |
Omega_h::CmdLineFlag::arg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | CmdLineItem* CmdLineFlag::arg(std::string const& arg_name) {
for (auto const& the_arg : args_)
if (the_arg->name() == arg_name) return the_arg.get();
OMEGA_H_NORETURN(nullptr);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x50(%rdi), %r14
movq 0x58(%rdi), %r15
cmpq %r15, %r14
je 0x14d23b
movq (%r14), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0xf1cd0
testb %al, %al
jne 0x14d232
addq $0x8, %r14
jmp 0x14d214
movq (%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x129e46(%rip), %rdi... | /gahansen[P]omega_h/src/Omega_h_cmdline.cpp |
Omega_h::CmdLineItem::parse(int*, char**, int, bool) | bool CmdLineItem::parse(int* p_argc, char** argv, int i, bool should_print) {
if (parsed_) {
if (should_print) {
std::cout << "argument <" << name() << " being parsed twice!\n";
}
return false;
}
auto ok = parse_impl(p_argc, argv, i, should_print);
if (ok) parsed_ = true;
return ok;
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x14d346
testb %r8b, %r8b
je 0x14d35f
movq 0x1c4a1e(%rip), %rdi # 0x311d38
leaq 0x12cf62(%rip), %rsi # 0x27a283
callq 0xf68a0
addq $0x8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf5810
leaq 0x12cec9(%rip), %rsi # 0x27a205
movq %rax, %rdi
callq 0xf68a0
jmp... | /gahansen[P]omega_h/src/Omega_h_cmdline.cpp |
Omega_h::CmdLineFlag::parse_impl(int*, char**, int, bool) | bool CmdLineFlag::parse_impl(
int* p_argc, char** argv, int i, bool should_print) {
shift(p_argc, argv, i);
if (((*p_argc) - i) < int(args_.size())) {
if (should_print) {
std::cout << "flag " << name() << " takes " << args_.size()
<< " arguments\n";
}
return false;
}
for (a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
movq %rdx, 0x10(%rsp)
movq %rdx, %rsi
movl %ecx, %edx
callq 0x14d199
movl (%r12), %eax
subl %r14d, %eax
movq 0x50(%r13), %rbp
movq 0x58(%r13), %rbx
movq %r... | /gahansen[P]omega_h/src/Omega_h_cmdline.cpp |
Omega_h::CmdLine::parse(int*, char**, bool) | bool CmdLine::parse(int* p_argc, char** argv, bool should_print) {
for (int i = 1; i < *p_argc;) {
bool parsed_by_flag = false;
for (auto const& flag : flags_) {
if (flag->name() == argv[i]) {
if (!flag->parse(p_argc, argv, i, should_print)) {
if (should_print) {
std::cout ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
pushq $0x1
popq %rax
movzbl %cl, %edx
movl %edx, 0x8(%rsp)
xorb $0x1, %cl
movl %ecx, 0x4(%rsp)
movq %rdi, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movslq %eax, %r13
cmpl (%r15), %r13d
jge 0x14d738
m... | /gahansen[P]omega_h/src/Omega_h_cmdline.cpp |
void Omega_h::CmdLineFlag::add_arg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void CmdLineFlag::add_arg(std::string const& arg_name, T const& defval) {
args_.push_back(
std::unique_ptr<CmdLineArg<T>>(new CmdLineArg<T>(arg_name, defval)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0xf6900
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x100900
addq $0x50, %rbx
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfa160
movq (%rsp), %rdi
tes... | /gahansen[P]omega_h/src/Omega_h_cmdline.cpp |
Omega_h::MetricEdgeLengths<2, 2>::MetricEdgeLengths(Omega_h::Mesh const*) | MetricEdgeLengths(Mesh const* mesh)
: MetricEdgeLengths(mesh, mesh->get_array<Real>(VERT, "metric")) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1258c1(%rip), %rsi # 0x278771
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xef870
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xf1f50
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
mov... | /gahansen[P]omega_h/src/Omega_h_shape.hpp |
Omega_h::MetricEdgeLengths<3, 1>::MetricEdgeLengths(Omega_h::Mesh const*) | MetricEdgeLengths(Mesh const* mesh)
: MetricEdgeLengths(mesh, mesh->get_array<Real>(VERT, "metric")) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x124fb9(%rip), %rsi # 0x278771
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xef870
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xf1f50
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
mov... | /gahansen[P]omega_h/src/Omega_h_shape.hpp |
Omega_h::get_verts_onto(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>) | LOs get_verts_onto(Mesh* mesh, LOs rails2edges, Read<I8> rail_col_dirs) {
auto nkeys = rails2edges.size();
auto ev2v = mesh->ask_verts_of(EDGE);
auto keys2verts_onto_w = Write<LO>(nkeys, -1);
auto set_key_onto = OMEGA_H_LAMBDA(LO key) {
auto e = rails2edges[key];
auto eev = rail_col_dirs[key];
keys2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq (%rdx), %r14
testb $0x1, %r14b
jne 0x15a10c
movq (%r14), %r14
jmp 0x15a110
shrq $0x3, %r14
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0xf3940
leaq 0x123393(%rip), %rsi # 0x27d... | /gahansen[P]omega_h/src/Omega_h_coarsen_topology.cpp |
Omega_h::mark_dead_ents(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>, int, Omega_h::Write<signed char>&, Omega_h::Write<signed char>&) | void mark_dead_ents(Mesh* mesh, LOs rails2edges, Read<I8> rail_col_dirs,
Int cell_dim, Write<I8>& dead_cells, Write<I8>& dead_sides) {
auto e2c = mesh->ask_up(EDGE, cell_dim);
auto e2ec = e2c.a2ab;
auto ec2c = e2c.ab2b;
auto ec_codes = e2c.codes;
auto cs2s = mesh->ask_down(cell_dim, cell_dim - 1).ab2b;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r9, %rbx
movq %r8, %r12
movl %ecx, %r13d
movq %rdx, (%rsp)
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x1f8(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf2f20
leaq 0x38(%rsp), %rdi
mo... | /gahansen[P]omega_h/src/Omega_h_coarsen_topology.cpp |
Omega_h::mark_dead_ents(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>) | HostFew<Read<I8>, 4> mark_dead_ents(
Mesh* mesh, LOs rails2edges, Read<I8> rail_col_dirs) {
HostFew<Write<I8>, 4> writes;
writes[EDGE] = deep_copy(mark_image(rails2edges, mesh->nedges()));
for (Int dim = Int(EDGE) + 1; dim <= mesh->dim(); ++dim)
writes[dim] = Write<I8>(mesh->nents(dim), 0);
for (Int dim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdx, 0x28(%rsp)
movq %rdx, %rsi... | /gahansen[P]omega_h/src/Omega_h_coarsen_topology.cpp |
r3d::tet_face_from_verts(r3d::Vector<3>, r3d::Vector<3>, r3d::Vector<3>) | R3D_INLINE Plane<3> tet_face_from_verts(Vector<3> a, Vector<3> b, Vector<3> c) {
auto center = ONE_THIRD * (a + b + c);
auto normal = normalize(cross((b - a), (c - a)));
auto d = -(normal * center);
return Plane<3>{normal, d};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x148(%rsp), %r12
movq %r12, %rdi
callq 0xfe090
leaq 0x130(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0xfe090
leaq 0x160(%rsp), %r... | /gahansen[P]omega_h/src/r3d.hpp |
Omega_h::(anonymous namespace)::lt(Omega_h::any&, Omega_h::any&) | any lt(any& lhs, any& rhs) {
if (lhs.type() == typeid(Real)) {
return any_cast<Real>(lhs) < any_cast<Real>(rhs);
} else if (lhs.type() == typeid(Reals)) {
return lt_each(any_cast<Reals>(lhs), any_cast<Reals>(rhs));
} else {
throw ParserFail("Invalid operand types to < operator");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x17d598
callq *(%rax)
movq %rax, %rdi
jmp 0x17d59f
movq 0x1946b9(%rip), %rdi # 0x311c58
movq 0x194a42(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
je 0x17d... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::(anonymous namespace)::eq(Omega_h::any&, Omega_h::any&) | any eq(any& lhs, any& rhs) {
if (lhs.type() == typeid(Real)) {
return any_cast<Real>(lhs) == any_cast<Real>(rhs);
} else if (lhs.type() == typeid(Reals)) {
return eq_each(any_cast<Reals>(lhs), any_cast<Reals>(rhs));
} else {
throw ParserFail("Invalid operand types to == operator");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x17d72c
callq *(%rax)
movq %rax, %rdi
jmp 0x17d733
movq 0x194525(%rip), %rdi # 0x311c58
movq 0x1948ae(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
je 0x17d... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::(anonymous namespace)::eval_pow(int, Omega_h::any&, Omega_h::any&) | any eval_pow(Int dim, any& lhs, any& rhs) {
if (dim == 3) return eval_pow<3>(lhs, rhs);
if (dim == 2) return eval_pow<2>(lhs, rhs);
return eval_pow<1>(lhs, rhs);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x1817cc
cmpl $0x3, %esi
jne 0x1817e3
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1817fa
callq *(%rax)
movq %rax, %rdi
jmp 0x181801
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x181868
callq *(%... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::AssignOp::eval(Omega_h::ExprEnv&) | any AssignOp::eval(ExprEnv& env) {
env.variables[name] = rhs->eval(env);
return any();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
addq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xf53e0
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xf1a10
movq 0x10(%r14... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::NegOp::eval(Omega_h::ExprEnv&) | any NegOp::eval(ExprEnv& env) { return neg(env.dim, rhs->eval(env)); } | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x64(%rdx), %ebp
movq 0x8(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x182532
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x182df3
leaq 0x8(%rsp), %rdi
cal... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::ExprEnv::string[abi:cxx11](int) | std::string ExprEnv::string(int verbose) {
//std::map<std::string, any> variables;
//std::map<std::string, Function> functions;
//LO size;
//Int dim;
std::ostringstream oss, vs;
std::string sep = "";
for(auto i : variables) {
auto v = i.second;
std::string str = any_cast<std::string>(v);
vs <<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x220(%rsp), %rdi
callq 0xfa530
leaq 0xa8(%rsp), %rdi
callq 0xfa530
movq %rbx, 0x10(%rsp)
leaq 0xf89ce(%rip), %rsi # 0x27d4b7
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rdx
... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::(anonymous namespace)::promote_bools(int, Omega_h::any&, Omega_h::any&) | void promote_bools(LO size, any& lhs, any& rhs) {
if (lhs.type() == typeid(bool) && rhs.type() == typeid(Bytes)) {
OMEGA_H_CHECK(any_cast<Bytes>(rhs).size() == size);
promote_bool(size, lhs);
}
if (lhs.type() == typeid(Bytes) && rhs.type() == typeid(bool)) {
OMEGA_H_CHECK(any_cast<Bytes>(lhs).size() =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x1850cd
callq *(%rax)
movq %rax, %rdi
jmp 0x1850d4
movq 0x18cb84(%rip), %rdi # 0x311c58
movq 0x18cbbd(%rip), %rsi # 0x311c98
callq 0xf2f10
testb %al, %al
je 0x185... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
std::vector<Omega_h::any, std::allocator<Omega_h::any>>& Omega_h::any_cast<std::vector<Omega_h::any, std::allocator<Omega_h::any>>&>(Omega_h::any&) | inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rax
callq 0xf3860
testq %rax, %rax
je 0x18888b
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0xf0720
movq 0x189666(%rip), %rcx # 0x311f00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x189108(%rip), %rsi # 0x3119b0
movq 0x1895c9(%rip), %rdx # 0x311e78
movq %rax, %rdi
callq 0xfeae0
nop
| /gahansen[P]omega_h/src/Omega_h_any.hpp |
Omega_h::CallOp::CallOp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Omega_h::any, std::allocator<Omega_h::any>> const&) | CallOp(std::string const& name_in, ExprEnv::Args const& args_in)
: name(name_in) {
for (auto& arg : args_in) {
OpPtr op = any_cast<OpPtr>(arg);
rhs.push_back(op);
}
args.reserve(rhs.size());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r12
movq 0x188dff(%rip), %rax # 0x311af0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0xfabe0
leaq 0x28(%r12), %r14
leaq 0x40(%r12), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, ... | /gahansen[P]omega_h/src/Omega_h_expr.cpp |
Omega_h::any::swap(Omega_h::any&) | void swap(any& rhs) noexcept {
if (this->vtable != rhs.vtable) {
any tmp(std::move(rhs));
// move from *this to rhs.
rhs.vtable = this->vtable;
if (this->vtable != nullptr) {
this->vtable->move(this->storage, rhs.storage);
// this->vtable = nullptr; -- uneeded, see below
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
je 0x1893a7
movq %rsp, %rdi
movq %r14, %rsi
callq 0xedf40
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x18938e
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq 0x10(%rsp), %rax
mo... | /gahansen[P]omega_h/src/Omega_h_any.hpp |
bool Omega_h::any_cast<bool>(Omega_h::any&) | inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rax
callq 0xfab30
testq %rax, %rax
je 0x1893ff
movb (%rax), %al
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0xf0720
movq 0x188af2(%rip), %rcx # 0x311f00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x188594(%rip), %rsi # 0x3119b0
movq 0x188a55(%rip), %rdx # 0x311e78
movq %rax, %rdi
callq 0xfeae0
nop
| /gahansen[P]omega_h/src/Omega_h_any.hpp |
Omega_h::binary::read(Omega_h::filesystem::path const&, std::shared_ptr<Omega_h::Comm>, bool) | Mesh read(filesystem::path const& path, CommPtr comm, bool strict) {
ScopedTimer timer("binary::read(path, comm, strict)");
auto mesh = Mesh(comm->library());
binary::read(path, comm, &mesh, strict);
return mesh;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xee796(%rip), %rdi # 0x27cc26
xorl %esi, %esi
callq 0xf9c20
movq (%r15), %rdi
callq 0x101500
movq %rbx, %rdi
movq %rax, %rsi
callq 0xff100
leaq 0x10(%rsp), %r12
movq %r12, %r... | /gahansen[P]omega_h/src/Omega_h_file.cpp |
Omega_h::filesystem::current_path() | path current_path() {
char buf[1024];
errno = 0;
char* ret = ::getcwd(buf, sizeof(buf));
if (ret == nullptr) {
throw filesystem_error(errno, "current_path");
}
return ret;
} | pushq %r14
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdi, %rbx
callq 0xec440
movq %rax, %r14
andl $0x0, (%rax)
movq %rsp, %rdi
movl $0x400, %esi # imm = 0x400
callq 0xf0ea0
testq %rax, %rax
je 0x1907e5
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf1a70
movq %rbx, %rax
addq $0x408, %rsp ... | /gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
Omega_h::filesystem::path::filename() const | path path::filename() const {
auto const last_sep_pos = impl.find_last_of(preferred_separator);
if (last_sep_pos == std::string::npos) return impl;
return impl.substr(last_sep_pos + 1, std::string::npos);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x101ae0
cmpq $-0x1, %rax
je 0x190b0f
incq %rax
movq %rsp, %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf7020
movq %rbx, %rdi
movq %r1... | /gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
Omega_h::filesystem::path::extension() const | path path::extension() const {
auto const filename_str = filename().native();
auto const last_dot_pos = filename_str.find_last_of('.');
// If the pathname is either . or .., or if filename() does not contain the .
// character, then empty path is returned.
if (last_dot_pos == std::string::npos) return path();... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xfa5d0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xfabe0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
pushq $0x2e
popq %rsi
pushq $-0x1
popq %rdx
callq 0x101ae0
cmpq $-0x1, %rax
je 0x190c54
movq %rax, %r14
l... | /gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
Omega_h::filesystem::IteratorImpl::increment() | void increment() {
errno = 0;
entry = ::readdir(stream);
if (entry == nullptr) {
if (errno != 0) {
throw filesystem_error(errno, "directory_iterator");
}
// safely reached the end of the directory
close();
} else {
// we just extracted a good entry from the stream
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xec440
movq %rax, %rbx
andl $0x0, (%rbx)
movq 0x20(%r14), %rdi
callq 0xfc930
movq %rax, 0x28(%r14)
testq %rax, %rax
je 0x191270
cmpb $0x2e, 0x13(%rax)
jne 0x191268
cmpb $0x0, 0x14(%rax)
je 0x19123b
cmpb $0x2e, 0x14(%rax)
jne 0x191268
cmpb $0x0, 0x15(%rax)
je 0x191... | /gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
Omega_h::add_transition(Omega_h::FiniteAutomaton&, int, int, int) | void add_transition(
FiniteAutomaton& fa, int from_state, int at_symbol, int to_state) {
OMEGA_H_CHECK(0 <= to_state);
OMEGA_H_CHECK(to_state < get_nstates(fa));
OMEGA_H_CHECK(0 <= at_symbol);
OMEGA_H_CHECK(
at_symbol < get_ncols(fa.table)); // allow setting epsilon transitions
OMEGA_H_CHECK(at(fa.... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %ecx, %ecx
js 0x19160a
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0xf0f90
cmpl %ebx, %eax
jle 0x191623
testl %ebp, %ebp
js 0x19163c
cmpl %ebp, 0x18(%r15)
jle 0x191655
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xffe00
c... | /gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
Omega_h::FiniteAutomaton::maybe(Omega_h::FiniteAutomaton const&, int) | FiniteAutomaton FiniteAutomaton::maybe(FiniteAutomaton const& a, int token) {
FiniteAutomaton out(get_nsymbols(a), false, get_nstates(a) + 2);
auto new_start_state = add_state(out);
auto offset = get_nstates(out);
append_states(out, a);
auto new_accept_state = add_state(out);
auto epsilon0 = get_epsilon0(ou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %eax
movzbl 0x38(%rsi), %ecx
leal (%rax,%rcx,2), %ebp
addl $-0x2, %ebp
movq %rsi, %rdi
callq 0xf0f90
leal 0x2(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %e... | /gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
Omega_h::FiniteAutomaton::simplify_once(Omega_h::FiniteAutomaton const&) | FiniteAutomaton FiniteAutomaton::simplify_once(FiniteAutomaton const& fa) {
StateRow2SimpleState sr2ss({fa.table, fa.accepted_tokens});
int nsimple = 0;
for (int state = 0; state < get_nstates(fa); ++state) {
auto res = sr2ss.insert(std::make_pair(state, nsimple));
if (res.second) {
++nsimple;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %rax
leaq 0x40(%rsp), %rcx
movq %rsi, -0x10(%rcx)
movq %rax, -0x8(%rcx)
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
xorl %ebp, ... | /gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
Omega_h::make_char_set_nfa(std::set<char, std::less<char>, std::allocator<char>> const&, int) | FiniteAutomaton make_char_set_nfa(std::set<char> const& accepted, int token) {
std::set<int> symbol_set;
for (auto c : accepted) symbol_set.insert(get_symbol(c));
return FiniteAutomaton::make_set_nfa(Omega_h::NCHARS, symbol_set, token);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x18(%rsi), %r12
addq $0x8, %r14
leaq 0x8(%rsp), %r15
lea... | /gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
Omega_h::operator<<(std::ostream&, Omega_h::FiniteAutomaton const&) | std::ostream& operator<<(std::ostream& os, FiniteAutomaton const& fa) {
if (get_determinism(fa))
os << "dfa ";
else
os << "nfa ";
os << get_nstates(fa) << " states " << get_nsymbols(fa) << " symbols\n";
for (int state = 0; state < get_nstates(fa); ++state) {
for (int symbol = 0; symbol < get_nsymbol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xea83f(%rip), %rax # 0x27d188
leaq 0xea83d(%rip), %rsi # 0x27d18d
cmpb $0x0, 0x38(%r14)
cmovneq %rax, %rsi
callq 0xf68a0
movq %r14, %rdi
callq 0xf0f90
movq %rbx, %rdi
movl %eax, %esi
callq 0xfed90
... | /gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
Omega_h::StateRowLess::operator()(int const&, int const&) const | bool operator()(int const& a, int const& b) const {
auto aa = at(accepted, a);
auto ab = at(accepted, b);
if (aa != ab) return aa < ab;
for (int symbol = 0, ncols = get_ncols(table); symbol < ncols; ++symbol) {
auto ea = at(table, a, symbol);
auto eb = at(table, b, symbol);
if (ea != e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movl (%rsi), %esi
callq 0xf2a70
movl (%rax), %ebp
movq 0x8(%r15), %rdi
movl (%rbx), %esi
callq 0xf2a70
cmpl (%rax), %ebp
jne 0x193a28
movq (%r15), %rax
movl 0x18(%rax), %r12d... | /gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp |
Omega_h::get_histogram(Omega_h::Mesh*, int, int, double, double, Omega_h::Read<double>) | Histogram get_histogram(Mesh* mesh, Int dim, Int nbins, Real min_value,
Real max_value, Reals values) {
OMEGA_H_CHECK(values.size() == mesh->nents(dim));
auto owned_values = mesh->owned_array(dim, values, 1);
auto interval = (max_value - min_value) / Real(nbins);
Histogram histogram;
histogram.min = min_v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r8, %r14
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, 0x38(%rsp)
movq (%r8), %r15
testb $0x1, %r15b
jne 0x1a32e7
movq (%r15), %r15
jmp 0x1a32e... | /gahansen[P]omega_h/src/Omega_h_histogram.cpp |
Omega_h::find_indset(Omega_h::Mesh*, int, Omega_h::Read<double>, Omega_h::Read<signed char>) | Read<I8> find_indset(
Mesh* mesh, Int ent_dim, Reals quality, Read<I8> candidates) {
if (ent_dim == mesh->dim()) return candidates;
mesh->owners_have_all_upward(ent_dim);
OMEGA_H_CHECK(mesh->owners_have_all_upward(ent_dim));
auto graph = mesh->ask_star(ent_dim);
return find_indset(mesh, ent_dim, graph, qu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
cmpl %ebp, %eax
jne 0x1a43ca
movq %rbx, %rdi
movq %r15, %rsi
callq 0x100b80
jmp 0x1a4463
movq %r14, %rdi
movl %ebp, %esi
callq 0... | /gahansen[P]omega_h/src/Omega_h_indset.cpp |
void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::indset::find<Omega_h::QualityCompare>(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>, Omega_h::QualityCompare)::'lambda'(int)&>(int, Omega_h::QualityCompare&&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xd31a2(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xd29d6(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9e... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::indset::find<Omega_h::QualityCompare>(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>, Omega_h::QualityCompare)::'lambda'(int)&>(Omega_h::QualityCompare, Omega_h::QualityCompare, Omega_h::Read<signed... | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1a4b4e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x16d1bb(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xf9810
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x1a4b3e
movq 0x8(%rsp), %rdx
mo... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
Omega_h::inertia::mark_bisection(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, Omega_h::Read<double>, double, Omega_h::Vector<3>&) | Read<I8> mark_bisection(
CommPtr comm, Reals coords, Reals masses, Real tolerance, Vector<3>& axis) {
OMEGA_H_CHECK(coords.size() == masses.size() * 3);
auto total_mass = repro_sum(comm, masses);
auto center = get_center(comm, coords, masses, total_mass);
axis = get_axis(comm, coords, masses, center);
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x578, %rsp # imm = 0x578
movq %r8, %r14
movsd %xmm0, 0x428(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdx), %rax
testb $0x1, %al
jne 0x1a5081
movq (%rax), %rax
jmp 0x1a5085
shrq $0x3, %rax
shrq $0x3, %r... | /gahansen[P]omega_h/src/Omega_h_inertia.cpp |
Omega_h::inertia::(anonymous namespace)::mark_bisection_internal(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, Omega_h::Read<double>, double, Omega_h::Vector<3>, Omega_h::Vector<3>, double) | Read<I8> mark_bisection_internal(CommPtr comm, Reals coords, Reals masses,
Real tolerance, Vector<3> axis, Vector<3> center, Real total_mass) {
auto dists = get_distances(coords, center, axis);
Read<I8> marked;
if (mark_axis_bisection(comm, dists, masses, total_mass, tolerance, marked)) {
return marked;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rcx, 0x58(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x108(%rsp), %r14
movq %r14, %rdi
movq %rdx, 0x80(%rsp)
movq %rdx, %rsi
callq 0xf3e40
movq 0x170(%rsp), ... | /gahansen[P]omega_h/src/Omega_h_inertia.cpp |
Omega_h::inertia::recursively_bisect(std::shared_ptr<Omega_h::Comm>, double, Omega_h::Read<double>*, Omega_h::Read<double>*, Omega_h::Remotes*, Omega_h::inertia::Rib*) | void recursively_bisect(CommPtr comm, Real tolerance, Reals* p_coords,
Reals* p_masses, Remotes* p_owners, Rib* p_hints) {
auto& coords = *p_coords;
auto& masses = *p_masses;
auto& owners = *p_owners;
auto& hints = *p_hints;
if (comm->size() == 1) {
return;
}
Vector<3> axis;
Read<I8> marks;
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rbp
movsd %xmm0, 0x18(%rsp)
movq %rdi, %r13
movq (%rdi), %rdi
callq 0xfa970
cmpl $0x1, %eax
je 0x1a80d7
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq... | /gahansen[P]omega_h/src/Omega_h_inertia.cpp |
Omega_h::inertia::(anonymous namespace)::mark_axis_bisection(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, Omega_h::Read<double>, double, double, Omega_h::Read<signed char>&) | bool mark_axis_bisection(CommPtr comm, Reals distances, Reals masses,
Real total_mass, Real tolerance, Read<I8>& marked) {
auto n = distances.size();
OMEGA_H_CHECK(n == masses.size());
auto minmax_dist = get_minmax(comm, distances);
auto range = max2(std::abs(minmax_dist.min), std::abs(minmax_dist.max));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rcx, 0x38(%rsp)
movsd %xmm1, 0x118(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x30(%rsp)
movq (%rsi), %rax
testb $0x1, %al
jne 0x1a85a8
movq (%rax), %rax
jmp 0x1a85ac
shrq $0x3, %rax
shrq... | /gahansen[P]omega_h/src/Omega_h_inertia.cpp |
Omega_h::Read<int> Omega_h::offset_scan<int>(Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | LOs offset_scan(Read<T> a, std::string const& name) {
OMEGA_H_TIME_FUNCTION;
Write<LO> out(a.size() + 1, name);
out.set(0, 0);
auto const first = CastIterator<LO, T>(a.begin());
auto const last = CastIterator<LO, T>(a.end());
auto const result = out.begin() + 1;
inclusive_scan(first, last, result);
retu... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd1578(%rip), %rsi # 0x27ec2c
leaq 0x60(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0xc9bcb(%rip), %rdx # 0x277295
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xed920
leaq 0x40(%rsp), %rdi
pushq... | /gahansen[P]omega_h/src/Omega_h_int_scan.cpp |
int* Omega_h::transform_inclusive_scan<int*, int*, Omega_h::maximum<int>, Omega_h::identity<int>>(int*, int*, int*, Omega_h::maximum<int>, Omega_h::identity<int>&&) | OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
OutputIterator result, BinaryOp op, UnaryOp&& transform) {
auto const n = last - first;
if (n <= 0) return result;
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parall... | movq %rdx, %rax
subq %rdi, %rsi
movq %rsi, %rcx
sarq $0x2, %rcx
testq %rcx, %rcx
jle 0x1ad8ce
movq 0x164419(%rip), %rdx # 0x311cc0
movb $0x0, (%rdx)
movl (%rdi), %edx
movl %edx, (%rax)
pushq $0x1
popq %r8
cmpq %r8, %rcx
je 0x1ad8cb
movl (%rdi,%r8,4), %r9d
cmpl %r9d, %edx
cmovlel %r9d, %edx
movl %edx, (%rax,%r8,4)
in... | /gahansen[P]omega_h/src/Omega_h_scan.hpp |
Omega_h::build_reader_tables(Omega_h::Language const&) | ReaderTablesPtr build_reader_tables(Language const& language) {
auto lexer = build_lexer(language);
auto indent_info = build_indent_info(language);
auto grammar = build_grammar(language);
auto parser = accept_parser(build_lalr1_parser(grammar));
return ReaderTablesPtr(new ReaderTables({parser, lexer, indent_i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0xf5300
xorl %r12d, %r12d
pushq $-0x1
popq %r13
movl %r13d, %r15d
xorl %ebp, %ebp
movl %r13d, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rax
subq... | /gahansen[P]omega_h/src/Omega_h_language.cpp |
Omega_h::find_total_globals(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>) | GO find_total_globals(CommPtr comm, Read<GO> globals) {
auto const a = get_max(comm, globals);
if (a < 0) return 0;
return a + 1;
} | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
callq 0xf21a0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xf3b80
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0xf5310
movq %rax, %rbx
movq %rsp, %rdi
callq 0x100060
leaq 0x18(%rsp), %rdi
callq 0xf6d50
leaq 0x1(%rbx), %rcx
xorl %eax, %eax
testq ... | /gahansen[P]omega_h/src/Omega_h_linpart.cpp |
Omega_h::compound_maps(Omega_h::Read<int>, Omega_h::Read<int>) | LOs compound_maps(LOs a2b, LOs b2c) {
OMEGA_H_TIME_FUNCTION;
LO na = a2b.size();
Write<LO> a2c(a2b.size());
auto f = OMEGA_H_LAMBDA(LO a) {
LO b = a2b[a];
LO c = b2c[b];
a2c[a] = c;
};
parallel_for(na, std::move(f));
return a2c;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xcd804(%rip), %rsi # 0x27f5bb
leaq 0xa8(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
callq 0xef870
leaq 0xc54c2(%rip), %rdx # 0x277295
leaq 0x58(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
Omega_h::invert_marks(Omega_h::Read<signed char>) | Read<I8> invert_marks(Read<I8> marks) {
Write<I8> out(marks.size());
auto f = OMEGA_H_LAMBDA(LO i) { out[i] = !marks[i]; };
parallel_for(out.size(), f, "invert_marks");
return out;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testb $0x1, %r15b
jne 0x1b23ae
movq (%r15), %r15
jmp 0x1b23b2
shrq $0x3, %r15
leaq 0xcb0fe(%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_map.cpp |
Omega_h::invert_map_by_sorting(Omega_h::Read<int>, int) | Graph invert_map_by_sorting(LOs a2b, LO nb) {
auto& ab2b = a2b;
auto ba2ab = sort_by_keys(ab2b);
auto ba2b = unmap(ba2ab, ab2b, 1);
auto b2ba = invert_funnel(ba2b, nb);
auto& ba2a = ba2ab;
return Graph(b2ba, ba2a);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0xf0580
leaq 0x88(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x101340
leaq 0x98(%rsp), %rdi
callq 0xff620
leaq 0x68(%rsp), %rdi
leaq 0x88(%rsp), %rbx
movq ... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::add_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int) | void add_into(Read<T> a_data, LOs a2b, Write<T> b_data, Int width) {
auto na = a2b.size();
OMEGA_H_CHECK(a_data.size() == na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = a2b[a];
for (Int j = 0; j < width; ++j) {
b_data[b * width + j] += a_data[a * width + j];
}
};
parallel_for(na, f, "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %r14
movq (%rsi), %rbx
testb $0x1, %bl
jne 0x1b401d
movq (%rbx), %rbx
jmp 0x1b4021
shrq $0x3, %rbx
shrq $0x2, %rbx
movq (%r14), %rax
testb $0x1, %al
jne 0x1b4031
movq (%rax), %rax
jmp 0x1b4035
shrq $0x3, %... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::parallel_for<void Omega_h::expand_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)::'lambda'(int)>(int, signed char&&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc2820(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xc2054(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9e... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::map_into_range<int>(Omega_h::Read<int>, int, int, Omega_h::Write<int>, int) | void map_into_range(
Read<T> a_data, LO begin, LO end, Write<T> b_data, Int width) {
auto na = end - begin;
OMEGA_H_CHECK(a_data.size() == na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = begin + a;
for (Int j = 0; j < width; ++j) {
b_data[b * width + j] = a_data[a * width + j];
}
};
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rdi, %r14
subl %esi, %ebx
movq (%rdi), %rax
testb $0x1, %al
jne 0x1b613a
movq (%rax), %rax
jmp 0x1b613e
shrq $0x3, %rax
shrq $0x2, %rax
movl %ebx, %edx
imull %r8d, %edx
cmpl %eax, %edx
jne 0x1b6198
leaq 0x10(%rsp), %r15
movl %esi, -0x8(%r15)
movl %... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::parallel_for<Omega_h::Write<int> Omega_h::unmap<int>(Omega_h::Read<int>, Omega_h::Read<int>, int)::'lambda'(int)>(int, int&&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc1387(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xc0bbb(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9e... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<Omega_h::MaxFunctor<int>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<int>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<int>::input_type>, int) | Read<typename Functor::input_type> fan_reduce_tmpl(
LOs a2b, Read<typename Functor::input_type> b_data, Int width) {
using T = typename Functor::input_type;
using VT = typename Functor::value_type;
OMEGA_H_CHECK(a2b.last() * width == b_data.size());
auto na = a2b.size() - 1;
Write<T> a_data(na * width);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf8ab0
imull %ebp, %eax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1b751e
movq (%rcx), %rcx
jmp 0x1b7522
shrq $0x3, %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
Omega_h::Write<long> Omega_h::unmap<long>(Omega_h::Read<int>, Omega_h::Read<long>, int) | Write<T> unmap(LOs a2b, Read<T> b_data, Int width) {
OMEGA_H_TIME_FUNCTION;
auto na = a2b.size();
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = a2b[a];
for (Int j = 0; j < width; ++j) {
a_data[a * width + j] = b_data[b * width + j];
}
};
parallel_for(na, std::move(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc747a(%rip), %rsi # 0x27f5bb
leaq 0x80(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xbf13b(%rip), %rdx # 0x277295
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
cal... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
Omega_h::Read<long> Omega_h::fan_reduce<long>(Omega_h::Read<int>, Omega_h::Read<long>, int, Omega_h_Op) | Read<T> fan_reduce(LOs a2b, Read<T> b_data, Int width, Omega_h_Op op) {
switch (op) {
case OMEGA_H_MIN:
return fan_reduce_tmpl<MinFunctor<T>>(a2b, b_data, width);
case OMEGA_H_MAX:
return fan_reduce_tmpl<MaxFunctor<T>>(a2b, b_data, width);
case OMEGA_H_SUM:
return fan_reduce_tmpl<SumFunc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x2, %r8d
je 0x1b8eeb
cmpl $0x1, %r8d
je 0x1b8eb7
testl %r8d, %r8d
jne 0x1b8f39
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
Omega_h::Read<Omega_h::SumFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<long>::input_type>, int) | Read<typename Functor::input_type> fan_reduce_tmpl(
LOs a2b, Read<typename Functor::input_type> b_data, Int width) {
using T = typename Functor::input_type;
using VT = typename Functor::value_type;
OMEGA_H_CHECK(a2b.last() * width == b_data.size());
auto na = a2b.size() - 1;
Write<T> a_data(na * width);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf8ab0
imull %ebp, %eax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1b932c
movq (%rcx), %rcx
jmp 0x1b9330
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::parallel_for<void Omega_h::map_into_range<double>(Omega_h::Read<double>, int, int, Omega_h::Write<double>, int)::'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 %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0x101530
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf54e0
movq %rsp, %rdi
callq 0xffa10
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xffa10
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Write<double> Omega_h::unmap<double>(Omega_h::Read<int>, Omega_h::Read<double>, int) | Write<T> unmap(LOs a2b, Read<T> b_data, Int width) {
OMEGA_H_TIME_FUNCTION;
auto na = a2b.size();
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = a2b[a];
for (Int j = 0; j < width; ++j) {
a_data[a * width + j] = b_data[b * width + j];
}
};
parallel_for(na, std::move(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc5801(%rip), %rsi # 0x27f5bb
leaq 0x80(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xbd4c2(%rip), %rdx # 0x277295
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
cal... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::expand_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int) | void expand_into(Read<T> a_data, LOs a2b, Write<T> b_data, Int width) {
OMEGA_H_TIME_FUNCTION;
auto na = a2b.size() - 1;
if(a_data.size() != na * width) printf("This error can happen when an array has been subsetted - check sync_array usage vs sync_subset_array:\n"
" a_dat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %r14d
movq %rdx, 0x18(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc50d8(%rip), %rsi # 0x27f5bb
leaq 0x78(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0xbcd9c(%rip), %rdx # 0x277295
leaq 0x98(%rsp), %rdi
leaq 0x... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
Omega_h::Read<Omega_h::SumFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<double>::input_type>, int) | Read<typename Functor::input_type> fan_reduce_tmpl(
LOs a2b, Read<typename Functor::input_type> b_data, Int width) {
using T = typename Functor::input_type;
using VT = typename Functor::value_type;
OMEGA_H_CHECK(a2b.last() * width == b_data.size());
auto na = a2b.size() - 1;
Write<T> a_data(na * width);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf8ab0
imull %ebp, %eax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1bafa4
movq (%rcx), %rcx
jmp 0x1bafa8
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::map_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)::'lambda'(int)::operator()(int) const | OMEGA_H_INLINE void* data() const noexcept { return direct_ptr; } | movq 0x8(%rdi), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %eax
xorl %ecx, %ecx
movl 0x10(%rdi), %edx
cmpl %edx, %ecx
jge 0x1bb358
movl %edx, %r8d
imull %esi, %r8d
addl %ecx, %r8d
movq 0x20(%rdi), %r9
movq 0x30(%rdi), %r10
movslq %r8d, %r8
movb (%r10,%r8), %r8b
imull %eax, %edx
addl %ecx, %edx
movslq %edx, %rdx
movb %r... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::map_value_into<signed char>(signed char, Omega_h::Read<int>, Omega_h::Write<signed char>)::'lambda'(int)>(signed char, signed char, void Omega_h::map_value_into<signed char>(signed char, Omega_h::Read<int>, Omega_h::Write<signed char>)::'lambda'(int)&&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1bb43d
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1568cf(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf5830
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x1bb42b
movb 0x28(%rsp), %... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
void Omega_h::expand_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)::'lambda'(int)::operator()(int) const | OMEGA_H_INLINE void* data() const noexcept { return direct_ptr; } | movq 0x8(%rdi), %rdx
movslq %esi, %rax
movl (%rdx,%rax,4), %ecx
cmpl 0x4(%rdx,%rax,4), %ecx
jge 0x1bb8bc
xorl %edx, %edx
movl 0x10(%rdi), %r8d
cmpl %r8d, %edx
jge 0x1bb8b4
movl %ecx, %r9d
imull %r8d, %r9d
imull %esi, %r8d
addl %edx, %r8d
movq 0x20(%rdi), %r10
movq 0x30(%rdi), %r11
movslq %r8d, %r8
movb (%r11,%r8), %r8b... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
void Omega_h::parallel_for<Omega_h::Read<Omega_h::MaxFunctor<signed char>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<signed char>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<signed char>::input_type>, int)::'lambda'(int)>(int, Omega_h::MaxFunctor<signed char> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf8f70
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf9620
movq %rsp, %rdi
callq 0xf4250
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf4250
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::expand_into<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Write<int>, int)::'lambda'(int)::operator()(int) const | LOs compound_maps(LOs a2b, LOs b2c) {
OMEGA_H_TIME_FUNCTION;
LO na = a2b.size();
Write<LO> a2c(a2b.size());
auto f = OMEGA_H_LAMBDA(LO a) {
LO b = a2b[a];
LO c = b2c[b];
a2c[a] = c;
};
parallel_for(na, std::move(f));
return a2c;
} | pushq %rbx
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %edx
cmpl 0x4(%rax,%rcx,4), %edx
jge 0x1bc6fc
movq 0x20(%rdi), %r8
movq 0x30(%rdi), %r9
xorl %r10d, %r10d
movl 0x10(%rdi), %r11d
cmpl %r11d, %r10d
jge 0x1bc6f8
movl %edx, %ebx
imull %r11d, %ebx
imull %esi, %r11d
addl %r10d, %r11d
movslq %r11d, %r11
m... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::parallel_for<Omega_h::Read<Omega_h::MaxFunctor<int>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<int>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<int>::input_type>, int)::'lambda'(int)>(int, Omega_h::MaxFunctor<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
movq %rsp, %r14
movq %r14, %rdi
callq 0xeeea0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf4f10
movq %rsp, %rdi
callq 0x1016d0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1016d0
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::expand_into<long>(Omega_h::Read<long>, Omega_h::Read<int>, Omega_h::Write<long>, int)::'lambda'(int)::operator()(int) const | LOs compound_maps(LOs a2b, LOs b2c) {
OMEGA_H_TIME_FUNCTION;
LO na = a2b.size();
Write<LO> a2c(a2b.size());
auto f = OMEGA_H_LAMBDA(LO a) {
LO b = a2b[a];
LO c = b2c[b];
a2c[a] = c;
};
parallel_for(na, std::move(f));
return a2c;
} | pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
movslq %esi, %rsi
movslq (%rcx,%rsi,4), %rax
movslq 0x4(%rcx,%rsi,4), %rcx
movslq 0x10(%rdi), %rdx
imull %edx, %esi
movslq %esi, %rsi
xorl %r8d, %r8d
testl %edx, %edx
cmovgl %edx, %r8d
movq %rax, %r9
imulq %rdx, %r9
shlq $0x3, %r9
shlq $0x3, %rdx
shlq $0x3, %rsi
cmpq %rcx, %ra... | /gahansen[P]omega_h/src/Omega_h_map.cpp |
void Omega_h::parallel_for<Omega_h::Read<Omega_h::SumFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<long>::input_type>, int)::'lambda'(int)>(int, Omega_h::SumFunctor<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 %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf97d0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf9fe0
movq %rsp, %rdi
callq 0xf6730
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf6730
movq %rbx, %rdi
callq 0xff4a0
nop
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::mark_class_closures(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&, Omega_h::Graph) | Read<I8> mark_by_class_dim(Mesh* mesh, Int ent_dim, Int class_dim) {
auto e2class_dim = mesh->get_array<I8>(ent_dim, "class_dim");
return each_eq_to(e2class_dim, static_cast<I8>(class_dim));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x8(%r8)
je 0x1c056a
movq %r8, %r14
cmpq $0x0, 0x18(%r8)
je 0x1c0586
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf15b0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xf8b70
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r... | /gahansen[P]omega_h/src/Omega_h_mark.cpp |
Omega_h::mark_class_closures(Omega_h::Mesh*, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>> const&, Omega_h::Graph*) | Read<I8> mark_class_closures(Mesh* mesh,
std::vector<ClassPair> const& class_pairs, Graph nodes2ents[4]) {
auto dim = mesh->dim();
OMEGA_H_CHECK(nodes2ents[dim].a2ab.exists());
auto nnodes = nodes2ents[dim].a2ab.size() - 1;
auto marks = Read<I8>(nnodes, I8(0));
for (int class_dim = 0; class_dim <= dim; ++... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, 0x28(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %rsi, %rdi
callq 0xfe5f0
cltq
movq %rax, 0x30(%rsp)
shlq $0x5, %rax
cmpq $0x0, 0x8(%r14,%rax)
je 0x1c0976
addq %r14, %rax
movq (%rax), %rbx
testb $0x1,... | /gahansen[P]omega_h/src/Omega_h_mark.cpp |
Omega_h::symms_inria2osh(int, Omega_h::Read<double>) | Reals symms_inria2osh(Int dim, Reals symms) {
if (dim == 3) return symms_inria2osh_dim<3>(symms);
if (dim == 2) return symms_inria2osh_dim<2>(symms);
if (dim == 1) return symms_inria2osh_dim<1>(symms);
OMEGA_H_NORETURN(Reals());
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x1c4d99
cmpl $0x2, %esi
je 0x1c4d7c
cmpl $0x3, %esi
jne 0x1c4dc7
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf3e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd720
jmp 0x1c4db4
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
Omega_h::Read<double> Omega_h::repeat_symm<3>(int, Omega_h::Matrix<3, 3>) | Reals repeat_symm(LO const n, Tensor<dim> const symm) {
return repeat_vector(n, symm2vector(symm));
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
movsd 0x90(%rsp), %xmm2
movsd 0xb0(%rsp), %xmm3
movsd %xmm0, 0x30(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm3, 0x40(%rsp)
movsd %xmm1, 0x48(%rsp)
movaps 0xa0(%rsp), %xmm0
shufps $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movup... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
Omega_h::Read<double> Omega_h::resize_symms_tmpl<2, 3>(Omega_h::Read<double>) | Reals resize_symms_tmpl(Reals old_symms) {
auto n = divide_no_remainder(old_symms.size(), symm_ncomps(old_dim));
Write<Real> new_symms(n * symm_ncomps(new_dim));
constexpr auto min_dim = min2(old_dim, new_dim);
auto f = OMEGA_H_LAMBDA(Int i) {
auto a = get_symm<old_dim>(old_symms, i);
auto b = zero_matr... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1c517e
movq (%rdi), %rdi
jmp 0x1c5182
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0xb8320(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
Omega_h::Read<double> Omega_h::matrices_times_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>) | Reals matrices_times_vectors_dim(Reals ms, Reals vs) {
auto n = divide_no_remainder(vs.size(), dim);
OMEGA_H_CHECK(ms.size() == n * matrix_ncomps(dim, dim));
auto out = Write<Real>(n * dim);
auto f = OMEGA_H_LAMBDA(LO i) {
set_vector(out, i, get_matrix<dim, dim>(ms, i) * get_vector<dim>(vs, i));
};
para... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %r14
testb $0x1, %r14b
jne 0x1c5713
movq (%r14), %r14
jmp 0x1c5717
shrq $0x3, %r14
shrq $0x3, %r14
movq (%r12), %rax
testb $0x1, %al
jne 0x1c5728
movq (%rax), %rax
jmp 0x1c572c
shrq $0x3,... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
Omega_h::Read<double> Omega_h::matrices_times_matrices_dim<2>(Omega_h::Read<double>, Omega_h::Read<double>) | Reals matrices_times_matrices_dim(Reals a, Reals b) {
auto n = divide_no_remainder(a.size(), matrix_ncomps(dim, dim));
OMEGA_H_CHECK(b.size() == n * matrix_ncomps(dim, dim));
auto out = Write<Real>(n * matrix_ncomps(dim, dim));
auto f = OMEGA_H_LAMBDA(LO i) {
set_matrix(out, i, get_matrix<dim, dim>(a, i) * ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1c5a36
movq (%rdi), %rdi
jmp 0x1c5a3a
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x4
popq %rsi
callq 0xfd130
movl %eax, %r12d
movq (%r14), %r13
testb $0x1, %r13b
j... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
Omega_h::Read<double> Omega_h::symms_inria2osh_dim<2>(Omega_h::Read<double>) | Reals symms_inria2osh_dim(Reals symms) {
auto n = divide_no_remainder(symms.size(), symm_ncomps(dim));
Write<Real> out(symms.size());
auto f = OMEGA_H_LAMBDA(LO i) {
auto iv = get_vector<symm_ncomps(dim)>(symms, i);
auto is = vector2symm_inria(iv);
auto ov = symm2vector(is);
set_vector(out, i, ov)... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1c5e94
movq (%rdi), %rdi
jmp 0x1c5e98
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
movq (%r14), %r15
testb $0x1, %r15b
jne 0x1c5eb4
movq (%r15), %r1... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
Omega_h::Read<double> Omega_h::symms_inria2osh_dim<1>(Omega_h::Read<double>) | Reals symms_inria2osh_dim(Reals symms) {
auto n = divide_no_remainder(symms.size(), symm_ncomps(dim));
Write<Real> out(symms.size());
auto f = OMEGA_H_LAMBDA(LO i) {
auto iv = get_vector<symm_ncomps(dim)>(symms, i);
auto is = vector2symm_inria(iv);
auto ov = symm2vector(is);
set_vector(out, i, ov)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x1c5fdb
movq (%r12), %r12
movq %r12, %r14
shrq $0x3, %r14
jmp 0x1c5fe6
movq %r12, %r14
shrq $0x6, %r14
shrq $0x3, %r12
leaq 0xb74ca(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0... | /gahansen[P]omega_h/src/Omega_h_matrix.cpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_times_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_times_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)::... | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1c73aa
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x14a96d(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xef900
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::parallel_for<Omega_h::Read<double> Omega_h::symms_inria2osh_dim<1>(Omega_h::Read<double>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::symms_inria2osh_dim<1>(Omega_h::Read<double>)::'lambda'(int)&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xaf8c7(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xaf0fb(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9e... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_to_symms_dim<1>(Omega_h::Read<double>)::'lambda'(int)&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_to_symms_dim<1>(Omega_h::Read<double>)::'lambda'(int)&) | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x1c8fdf
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x148d2f(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xffd10
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movslq %ebp,... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
Omega_h::Mesh::ask_qualities() | Reals Mesh::ask_qualities() {
if (!has_tag(dim(), "quality")) {
auto qualities = measure_qualities(this);
add_tag(dim(), "quality", 1, qualities);
}
return get_array<Real>(dim(), "quality");
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
movl %eax, %ebp
leaq 0xaf1f5(%rip), %rsi # 0x27a488
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xef870
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0xf6400
movl %eax, %ebp
leaq 0x20(... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Mesh::set_parting(Omega_h_Parting, int, bool) | void Mesh::set_parting(Omega_h_Parting parting_in, Int nlayers, bool verbose) {
if (verbose && comm_->rank() == 0) {
std::cout << "going to ";
switch (parting_in) {
case OMEGA_H_ELEM_BASED:
std::cout << "element based";
break;
case OMEGA_H_VERT_BASED:
std::cout << "vertex b... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x1cbec8
movq 0x8(%r14), %rdi
callq 0xf0630
testl %eax, %eax
jne 0x1cbec8
movq 0x145ee9(%rip), %rdi # 0x311d38
leaq 0xb4240(%rip), %rsi # 0x280096
callq 0xf68a0
cmpl $0x2, %... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Mesh::imbalance(int) const | Real Mesh::imbalance(Int ent_dim) const {
if (ent_dim == -1) ent_dim = dim();
auto local = Real(nents(ent_dim));
auto s = comm_->allreduce(local, OMEGA_H_SUM);
if (s == 0.0) return 1.0;
auto m = comm_->allreduce(local, OMEGA_H_MAX);
auto n = comm_->size();
auto a = s / n;
return m / a;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
jne 0x1cda95
movq %rbx, %rdi
callq 0xfe5f0
movl %eax, %esi
movq %rbx, %rdi
callq 0xf0100
cvtsi2sd %eax, %xmm0
movq 0x8(%rbx), %rdi
pushq $0x2
popq %rsi
movsd %xmm0, (%rsp)
callq 0xf3800
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x1cdacc
... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::get_all_mesh_tags[abi:cxx11](Omega_h::Mesh*) | TagSet get_all_mesh_tags(Mesh* mesh) {
TagSet out;
for (Int i = 0; i <= mesh->dim(); ++i) {
for (Int j = 0; j < mesh->ntags(i); ++j) {
auto tagbase = mesh->get_tag(i, j);
out[size_t(i)].insert(tagbase->name());
}
}
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf7c90
xorl %r15d, %r15d
movq %r14, %rdi
callq 0xfe5f0
cltq
cmpq %rax, %r15
jg 0x1ce4e6
imulq $0x30, %r15, %r12
addq %rbx, %r12
xorl %ebp, %ebp
movq %r14, %rdi
movl %r15d, %esi
callq 0xf4870
cmpl %eax, %ebp
jge 0x1ce4e1
movq %... | /gahansen[P]omega_h/src/Omega_h_mesh.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.