name string | code string | asm string | file string |
|---|---|---|---|
Omega_h::ents_on_closure(Omega_h::Mesh*, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> con... | LOs ents_on_closure(
Mesh* mesh, std::set<std::string> const& class_names, Int ent_dim) {
auto class_pairs = to_class_pairs(mesh, class_names);
auto ents_are_on = mark_class_closures(mesh, ent_dim, class_pairs);
return collect_marked(ents_are_on);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1ce695
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x1010f0
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8e10
movq %rsp, %rsi
movq ... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Read<signed char> Omega_h::Mesh::sync_array<signed char>(int, Omega_h::Read<signed char>, int) | Read<T> Mesh::sync_array(Int ent_dim, Read<T> a, Int width) {
OMEGA_H_TIME_FUNCTION;
if (!could_be_shared(ent_dim)) return a;
return ask_dist(ent_dim).invert().exch(a, width);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xb10af(%rip), %rsi # 0x27fcc4
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0xa866a(%rip), %rdx # 0x277295
leaq... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Read<signed char> Omega_h::Mesh::owned_array<signed char>(int, Omega_h::Read<signed char>, int) | Read<T> Mesh::owned_array(Int ent_dim, Read<T> a, Int width) {
OMEGA_H_CHECK(a.size() == width * nents(ent_dim));
if (!could_be_shared(ent_dim)) return a;
auto o = owned(ent_dim);
auto o2e = collect_marked(o);
return unmap(o2e, a, width);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq (%rcx), %r13
testb $0x1, %r13b
jne 0x1cef0a
movq (%r13), %r13
jmp 0x1cef0e
shrq $0x3, %r13
movq %r12, %rdi
movl %r15d, %esi
callq 0xf0100
imull %ebp, %... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Read<int> Omega_h::Mesh::sync_array<int>(int, Omega_h::Read<int>, int) | Read<T> Mesh::sync_array(Int ent_dim, Read<T> a, Int width) {
OMEGA_H_TIME_FUNCTION;
if (!could_be_shared(ent_dim)) return a;
return ask_dist(ent_dim).invert().exch(a, width);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xb03af(%rip), %rsi # 0x27fcc4
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0xa796a(%rip), %rdx # 0x277295
leaq... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Read<int> Omega_h::Mesh::owned_array<int>(int, Omega_h::Read<int>, int) | Read<T> Mesh::owned_array(Int ent_dim, Read<T> a, Int width) {
OMEGA_H_CHECK(a.size() == width * nents(ent_dim));
if (!could_be_shared(ent_dim)) return a;
auto o = owned(ent_dim);
auto o2e = collect_marked(o);
return unmap(o2e, a, width);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq (%rcx), %r13
testb $0x1, %r13b
jne 0x1cfc0a
movq (%r13), %r13
jmp 0x1cfc0e
shrq $0x3, %r13
shrq $0x2, %r13
movq %r12, %rdi
movl %r15d, %esi
callq 0xf01... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
void Omega_h::Mesh::set_tag<long>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Omega_h::Read<long>, bool) | void Mesh::set_tag(
Int ent_dim, std::string const& name, Read<T> array, bool internal) {
this->add_tag(ent_dim, name, divide_no_remainder(array.size(), nents(ent_dim)), array, internal);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, (%rsp)
movl %esi, %r14d
movq %rdi, %r15
movq (%rcx), %r13
testb $0x1, %r13b
jne 0x1d0561
movq (%r13), %r13
jmp 0x1d0565
shrq $0x3, %r13
shrq $0x3, %r13
movq %r15, %rdi
movl %r14d, %esi
callq 0xf... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::Read<double> Omega_h::Mesh::sync_subset_array<double>(int, Omega_h::Read<double>, Omega_h::Read<int>, double, int) | Read<T> Mesh::sync_subset_array(
Int ent_dim, Read<T> a_data, LOs a2e, T default_val, Int width) {
if (!could_be_shared(ent_dim)) return a_data;
auto e_data = map_onto(a_data, a2e, nents(ent_dim), default_val, width);
e_data = sync_array(ent_dim, e_data, width);
return unmap(a2e, e_data, width);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %ebp
movsd %xmm0, 0x20(%rsp)
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0xf80a0
testb %al, %al
je 0x1d18bd
movq %r14, 0x10(%rsp)
leaq 0x78(%rsp), %r14
... | /gahansen[P]omega_h/src/Omega_h_mesh.cpp |
Omega_h::get_metrics_dim(int, Omega_h::Read<double>) | Int get_metrics_dim(LO nmetrics, Reals metrics) {
auto ncomps = divide_no_remainder(metrics.size(), nmetrics);
return get_metric_dim(ncomps);
} | movl %edi, %eax
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1d33d1
movq (%rdi), %rdi
jmp 0x1d33d5
shrq $0x3, %rdi
pushq %rax
shrq $0x3, %rdi
movl %eax, %esi
callq 0xfd130
movl %eax, %edi
popq %rax
jmp 0xeffc0
| /gahansen[P]omega_h/src/Omega_h_metric.cpp |
Omega_h::project_metrics(Omega_h::Mesh*, Omega_h::Read<double>) | Reals project_metrics(Mesh* mesh, Reals e2m) {
auto metric_dim = get_metrics_dim(mesh->nelems(), e2m);
if (metric_dim == 3)
return project_metrics_dim<3>(mesh, e2m);
else if (metric_dim == 2)
return project_metrics_dim<2>(mesh, e2m);
else if (metric_dim == 1)
return project_metrics_dim<1>(mesh, e2m)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xff990
movl %eax, %ebp
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf3e40
movl %ebp, %edi
movq %r12, %rsi
callq 0xfbf10
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
ca... | /gahansen[P]omega_h/src/Omega_h_metric.cpp |
Omega_h::get_curvature_metrics(Omega_h::Mesh*, double) | Reals get_curvature_metrics(Mesh* mesh, Real segment_angle) {
auto surface_info = get_surface_info(mesh);
auto out = Write<Real>(mesh->nverts() * symm_ncomps(mesh->dim()), 0.0);
if (mesh->dim() == 3) {
/* this algorithm creates degenerate metrics that only specify size in
the two tangential directions ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x568, %rsp # imm = 0x568
movsd %xmm0, 0x118(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3d0(%rsp), %rdi
callq 0xeced0
movq %r14, %rdi
callq 0xfbde0
movl %eax, %ebp
movq %r14, %rdi
callq 0xfe5f0
movl %eax, %r15d
leaq 0xa8659(%rip), %rsi... | /gahansen[P]omega_h/src/Omega_h_metric.cpp |
Omega_h::get_nelems_per_elem(Omega_h::Mesh*, Omega_h::Read<double>) | Reals get_nelems_per_elem(Mesh* mesh, Reals v2m) {
auto complexity = get_complexity_per_elem(mesh, v2m);
return multiply_each_by(
complexity, 1.0 / typical_unit_simplex_size(mesh->dim()));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf3e40
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x100970
leaq 0x20(%rsp), %rdi
callq 0xfdc90
movq %rsp, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0xf3e... | /gahansen[P]omega_h/src/Omega_h_metric.cpp |
Omega_h::get_expected_nelems(Omega_h::Mesh*, Omega_h::Read<double>) | Real get_expected_nelems(Mesh* mesh, Reals v2m) {
auto complexity = get_complexity(mesh, v2m);
return get_expected_nelems_from_complexity(complexity, mesh->dim());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf3e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfec10
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xfe5f0
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %dl
cmpl $0x3, %eax
je 0x1d662a
movb %dl, %cl
... | /gahansen[P]omega_h/src/Omega_h_metric.cpp |
Omega_h::Read<double> Omega_h::delinearize_metrics_dim<2>(Omega_h::Read<double>) | Reals delinearize_metrics_dim(Reals lms) {
auto n = divide_no_remainder(lms.size(), symm_ncomps(dim));
auto out = Write<Real>(n * symm_ncomps(dim));
auto f = OMEGA_H_LAMBDA(LO i) {
set_symm(out, i, delinearize_metric(get_symm<dim>(lms, i)));
};
parallel_for(n, f, "delinearize_metrics");
return out;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1d8248
movq (%rdi), %rdi
jmp 0x1d824c
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %r15d
leaq 0xa5255(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp... | /gahansen[P]omega_h/src/Omega_h_metric.cpp |
Omega_h::Read<double> Omega_h::limit_gradation_once_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<double>, double) | Reals limit_gradation_once_tmpl(
Mesh* mesh, Reals values, Real max_rate) {
auto v2v = mesh->ask_star(VERT);
auto coords = mesh->coords();
auto out = Write<Real>(mesh->nverts() * symm_ncomps(metric_dim));
auto f = OMEGA_H_LAMBDA(LO v) {
auto m = get_symm<metric_dim>(values, v);
auto x = get_vector<m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb8(%rsp), %rdi
xorl %edx, %edx
callq 0xf6cd0
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xffe20
movq %r15, %rdi
callq 0xfbde0
movl %eax, %ebp
leaq 0xa1fa0(%r... | /gahansen[P]omega_h/src/Omega_h_metric.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::limit_gradation_once_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<double>, double)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::limit_gradation_once_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<double>, double)::'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 $0x58, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xfad00
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf8770
movq %rsp, %rdi
callq 0xf5920
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf5920
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Matrix<2, 2> Omega_h::average_metric_finish<2>(Omega_h::Matrix<2, 2>, int, bool) | OMEGA_H_INLINE_BIG Tensor<dim> average_metric_finish(
Tensor<dim> am, Int const n, bool const has_degen) {
if (has_degen && n == 0) return am;
am /= n;
return delinearize_metric(am);
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorb $0x1, %dl
leaq 0x90(%rsp), %rax
testl %esi, %esi
setne %cl
orb %dl, %cl
jne 0x1f0ce4
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x1f0d6b
cvtsi2sd %esi, %xmm0
movupd (%rax), %xmm1
movups 0x10(%rax), %xmm2
movaps %xmm2, ... | /gahansen[P]omega_h/src/Omega_h_metric.hpp |
Omega_h::Matrix<2, 2> Omega_h::exp_spd_old<2>(Omega_h::Matrix<2, 2>) | OMEGA_H_INLINE_BIG Tensor<dim> exp_spd_old(
Tensor<dim> const m) OMEGA_H_NOEXCEPT {
auto decomp = decompose_eigen(m);
for (Int i = 0; i < dim; ++i) decomp.l[i] = std::exp(decomp.l[i]);
return compose_ortho(decomp.q, decomp.l);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
movapd 0x150(%rsp), %xmm0
movaps 0x160(%rsp), %xmm1
leaq 0x30(%rsp), %rax
movapd %xmm0, (%rax)
movaps %xmm1, 0x10(%rax)
xorpd %xmm4, %xmm4
xorl %ecx, %ecx
movapd 0x87610(%rip), %xmm2 # 0x278ac0
cmpq $0x2, %rcx
je 0... | /gahansen[P]omega_h/src/Omega_h_eigen.hpp |
Omega_h::Matrix<1, 1> Omega_h::exp_spd_old<1>(Omega_h::Matrix<1, 1>) | OMEGA_H_INLINE_BIG Tensor<dim> exp_spd_old(
Tensor<dim> const m) OMEGA_H_NOEXCEPT {
auto decomp = decompose_eigen(m);
for (Int i = 0; i < dim; ++i) decomp.l[i] = std::exp(decomp.l[i]);
return compose_ortho(decomp.q, decomp.l);
} | pushq %rax
movapd 0x867df(%rip), %xmm2 # 0x278ac0
andpd %xmm0, %xmm2
xorpd %xmm1, %xmm1
maxsd %xmm1, %xmm2
movsd 0x8c02b(%rip), %xmm3 # 0x27e320
ucomisd %xmm2, %xmm3
jae 0x1f2333
divsd %xmm2, %xmm0
movapd 0x867b9(%rip), %xmm1 # 0x278ac0
andpd %xmm0, %xmm1
ucomisd %xmm1, %xmm3
jae 0x1f232b
movapd %xmm0, %xmm1
s... | /gahansen[P]omega_h/src/Omega_h_eigen.hpp |
Omega_h::add_implied_metric_tag(Omega_h::Mesh*) | void add_implied_metric_tag(Mesh* mesh) {
auto metrics = get_implied_metrics(mesh);
add_metric_tag(mesh, metrics, "metric");
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xec850
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x7c972(%rip), %rsi # 0x278771
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %... | /gahansen[P]omega_h/src/Omega_h_metric_input.cpp |
void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::reduce_data_to_owners<long>(Omega_h::Read<long>, Omega_h::Dist, int)::'lambda'(int)>(int, long const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf7600
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf84e0
movq %rsp, %rdi
callq 0xee720
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xee720
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
int Omega_h::get_nrows<Omega_h::Action>(Omega_h::Table<Omega_h::Action> const&) | int get_nrows(Table<T> const& t) {
OMEGA_H_CHECK(t.ncols > 0);
OMEGA_H_CHECK(size(t.data) % t.ncols == 0);
return size(t.data) / t.ncols;
} | pushq %rax
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jle 0x207e2a
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x3, %rax
cltd
idivl %ecx
testl %edx, %edx
jne 0x207e43
popq %rcx
retq
leaq 0x6f257(%rip), %rdi # 0x277088
leaq 0x753f3(%rip), %rsi # 0x27d22b
leaq 0x7538c(%rip), %rdx # 0x27d1cb
pushq $0x18
jmp 0x207... | /gahansen[P]omega_h/src/Omega_h_table.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_qualities_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_qualities_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'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 $0x58, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf8220
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf1b80
leaq 0x8(%rsp), %rdi
callq 0xef780
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xef780
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::derive_element_gradients_dim<1>(Omega_h::Mesh*, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::derive_element_gradients_dim<1>(Omega_h::Mesh*, Omega_h::Read<double>)::'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 $0x48, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf1eb0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xeff00
leaq 0x8(%rsp), %rdi
callq 0xfce00
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfce00
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::derive_element_hessians_dim<1>(Omega_h::Mesh*, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::derive_element_hessians_dim<1>(Omega_h::Mesh*, Omega_h::Read<double>)::'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 $0x48, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf2260
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf7b30
leaq 0x8(%rsp), %rdi
callq 0xf9d50
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9d50
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::regex::build_language() | Language build_language() {
/* The top produtions were from the "grep.y" YACC grammar in the source
code for Plan 9's grep utility, see here:
https://github.com/wangeguo/plan9/blob/master/sys/src/cmd/grep/grep.y
The "set" related productions
are from a grammar intended to be used by ProLog to parse Per... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x18(%rdi), %r14
pushq $0x16
popq %rsi
movq %r14, %rdi
callq 0xf32a0
leaq 0x5fc1f(%rip), %rsi # 0x281e68
leaq 0x40(%rsp), %rdi
leaq 0x3(%rsp), %... | /gahansen[P]omega_h/src/Omega_h_regex.cpp |
Omega_h::regex::Reader::at_shift(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | any regex::Reader::at_shift(int token, std::string& text) {
if (token != TOK_CHAR) {
return any();
}
if (size(text) == 1) {
return any(text[0]);
} else if (size(text) == 2) {
OMEGA_H_CHECK(text[0] == '\\');
return any(text[1]);
} else {
std::cerr << "BUG: regex char text is \"" << text << ... | pushq %rbx
testl %edx, %edx
je 0x223d74
andq $0x0, 0x10(%rdi)
jmp 0x223dae
movq %rcx, %rbx
movl 0x8(%rcx), %eax
cmpl $0x2, %eax
je 0x223d96
cmpl $0x1, %eax
jne 0x223db3
movq (%rbx), %rax
movq 0xede3a(%rip), %rcx # 0x311bc8
movq %rcx, 0x10(%rdi)
movb (%rax), %al
jmp 0x223dac
movq (%rbx), %rax
cmpb $0x5c, (%rax)
jne ... | /gahansen[P]omega_h/src/Omega_h_regex.cpp |
void Omega_h::unite_with<char>(std::set<char, std::less<char>, std::allocator<char>>&, std::set<char, std::less<char>, std::allocator<char>> 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 0x224972
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xef760
movq %r15, %rdi
callq 0xf86e0
movq %rax, %r15
jmp 0x224954
popq %rbx
popq %r14
popq %r15
retq
| /gahansen[P]omega_h/src/Omega_h_set.hpp |
Omega_h::identity_remotes(std::shared_ptr<Omega_h::Comm>, int) | Remotes identity_remotes(CommPtr comm, LO n) {
return Remotes(Read<I32>(n, comm->rank()), LOs(n, 0, 1));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0xf0630
movl %eax, %r14d
leaq 0x581c8(%rip), %rsi # 0x27d4b7
leaq 0x48(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0xef870
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %r15,... | /gahansen[P]omega_h/src/Omega_h_remotes.cpp |
Omega_h::reorder_by_globals(Omega_h::Mesh*) | void reorder_by_globals(Mesh* mesh) {
LOs new_ents2old_ents[4];
for (Int ent_dim = 0; ent_dim <= mesh->dim(); ++ent_dim) {
new_ents2old_ents[ent_dim] = sort_by_keys(mesh->globals(ent_dim));
}
unmap_mesh(mesh, new_ents2old_ents);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
xorl %r15d, %r15d
movq %rsp, %r12
leaq 0x10(%rsp), %r13
pushq $0x1
popq %rbp
movq %r... | /gahansen[P]omega_h/src/Omega_h_reorder.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::get_linear_scatter_coords<1>(Omega_h::Read<double>, Omega_h::Vector<1>, Omega_h::Vector<1>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::get_linear_scatter_coords<1>(Omega_h::Read<double>, Omega_h::Vector<1>, Omega_h::Vector<1>)::'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 0x516c2(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x50ef6(%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::parallel_for<Omega_h::Read<double> Omega_h::get_radial_scatter_coords<1>(Omega_h::Read<double>, Omega_h::Vector<1>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::get_radial_scatter_coords<1>(Omega_h::Read<double>, Omega_h::Vector<1>)::'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 0x51474(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x50ca8(%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::parallel_for<Omega_h::Read<double> Omega_h::get_linear_scatter_coords<2>(Omega_h::Read<double>, Omega_h::Vector<2>, Omega_h::Vector<2>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::get_linear_scatter_coords<2>(Omega_h::Read<double>, Omega_h::Vector<2>, Omega_h::Vector<2>)::'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 0x50f66(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x5079a(%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::parallel_for<Omega_h::Read<double> Omega_h::get_radial_scatter_coords<2>(Omega_h::Read<double>, Omega_h::Vector<2>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::get_radial_scatter_coords<2>(Omega_h::Read<double>, Omega_h::Vector<2>)::'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 0x50d01(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x50535(%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::write_linear_scatterplot<2>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Omega_h::Mesh*, int, Omega_h::Read<double>, Omega_h::Vector<2>, Omega_h::Vector<2>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void write_linear_scatterplot(std::string const& path, Mesh* mesh, Int ent_dim,
Reals data, Vector<dim> direction, Vector<dim> origin,
std::string const& separator) {
auto coords =
average_field(mesh, ent_dim, dim, mesh->coords()); // get centroids
auto coords_1d = get_linear_scatter_coords(coords, d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0xffe20
leaq 0x68(%... | /gahansen[P]omega_h/src/Omega_h_scatterplot.cpp |
Omega_h::Read<double> Omega_h::get_linear_scatter_coords<3>(Omega_h::Read<double>, Omega_h::Vector<3>, Omega_h::Vector<3>) | Reals get_linear_scatter_coords(
Reals coords, Vector<dim> direction, Vector<dim> origin) {
auto offset = origin * direction;
auto n = divide_no_remainder(coords.size(), dim);
auto coords_1d_w = Write<Real>(n);
auto f = OMEGA_H_LAMBDA(LO i) {
auto x = get_vector<dim>(coords, i);
auto d = x * directi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb0(%rsp), %r15
movq 0xd8(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0xc8(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movapd (%r15), %xmm0
movapd %xmm0, 0x40(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x50(%rsp)
movsd 0x10(%rsp), %xm... | /gahansen[P]omega_h/src/Omega_h_scatterplot.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::get_radial_scatter_coords<3>(Omega_h::Read<double>, Omega_h::Vector<3>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::get_radial_scatter_coords<3>(Omega_h::Read<double>, Omega_h::Vector<3>)::'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 0x50532(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x4fd66(%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::get_linear_scatter_coords<1>(Omega_h::Read<double>, Omega_h::Vector<1>, Omega_h::Vector<1>)::'lambda'(int)&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::get_linear_scatter_coords<1>(Omega_h::Read<double>, Omega_h:... | OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
} | cmpl %esi, %edi
jge 0x227944
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0xea3d6(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf3060
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x28(%r14), %rcx
movslq %ebp,... | /gahansen[P]omega_h/src/Omega_h_int_iterator.hpp |
Omega_h::measure_edges_metric(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric(Mesh* mesh, LOs a2e, Reals metrics) {
if (a2e.size() == 0) return Reals({});
auto metric_dim = get_metrics_dim(mesh->nverts(), metrics);
if (mesh->dim() == 3 && metric_dim == 3) {
return measure_edges_metric_tmpl<3, 3>(mesh, a2e, metrics);
} else if (mesh->dim() == 2 && metric_dim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
testb $0x1, %al
jne 0x227f0d
movq (%rax), %rax
jmp 0x227f11
shrq $0x3, %rax
shrq $0x2, %rax
testl %eax, %eax
je 0x227fc0
movq %r14, %rdi
callq 0xfbde0
movl... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::measure_edges_metric(Omega_h::Mesh*, Omega_h::Read<int>) | Reals measure_edges_metric(Mesh* mesh, LOs a2e) {
return measure_edges_metric(mesh, a2e, mesh->get_array<Real>(VERT, "metric"));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movq %rdx, %rsi
callq 0xf0580
leaq 0x50510(%rip), %rsi # 0x278771
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xf1f50
leaq 0x18(%... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::measure_edges_metric(Omega_h::Mesh*, Omega_h::Read<double>) | Reals measure_edges_metric(Mesh* mesh, Reals metrics) {
return measure_edges_metric(mesh, LOs(mesh->nedges(), 0, 1), metrics);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xee2f0
movl %eax, %ebp
leaq 0x5519c(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0xef870
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rc... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::measure_ents_real(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real(Mesh* mesh, Int ent_dim, LOs a2e, Reals coords) {
if (mesh->dim() == 3 && ent_dim == 3)
return measure_ents_real_tmpl<3, 3>(mesh, a2e, coords);
if (mesh->dim() == 3 && ent_dim == 2)
return measure_ents_real_tmpl<3, 2>(mesh, a2e, coords);
if (mesh->dim() == 3 && ent_dim == 1)
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r12
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
xorl $0x3, %eax
movl %ebp, %ecx
xorl $0x3, %ecx
orl %eax, %ecx
jne 0x2284c4
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r13, %rs... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0xf3e40
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xf6270
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0xf3e40
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xf1740
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58ac3(%rip), %rsi # 0x282414
leaq 0x88(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xef870
leaq 0x4d92b(%rip), %rdx # 0x277295
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xed920
... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x587ce(%rip), %rsi # 0x282414
leaq 0x88(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xef870
leaq 0x4d636(%rip), %rdx # 0x277295
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xed920
... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x584d9(%rip), %rsi # 0x282414
leaq 0x88(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xef870
leaq 0x4d341(%rip), %rdx # 0x277295
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xed920
... | /gahansen[P]omega_h/src/Omega_h_shape.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char ... | 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 $0x58, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xee9b0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xfd340
leaq 0x8(%rsp), %rdi
callq 0xfba30
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfba30
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char ... | 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 $0x58, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x100180
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf8190
leaq 0x8(%rsp), %rdi
callq 0xfbe10
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfbe10
movq %rbx, %rdi
callq 0... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'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 $0x48, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf5260
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xfcf20
leaq 0x8(%rsp), %rdi
callq 0xf2ae0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf2ae0
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'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 $0x48, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf2a50
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf71f0
leaq 0x8(%rsp), %rdi
callq 0xfc790
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfc790
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'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 $0x48, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf2bd0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf3300
leaq 0x8(%rsp), %rdi
callq 0xf2240
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf2240
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)::operator()(int) const | OMEGA_H_INLINE void* data() const noexcept { return direct_ptr; } | movq 0x8(%rdi), %rcx
movslq %esi, %rax
movl (%rcx,%rax,4), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq 0x18(%rdi), %rcx
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x22d011
movl (%rcx,%rdx,4), %esi
movl %esi, -0x18(%rsp,%rdx,4)
incq %rdx
jmp 0x22cfff
movq 0x38(%rdi), %rcx
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x22d... | /gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp |
Omega_h::Read<int> Omega_h::sort_by_keys<int>(Omega_h::Read<int>, int) | LOs sort_by_keys(Read<T> keys, Int width) {
if (width == 1) return sort_by_keys_tmpl<1>(keys);
if (width == 2) return sort_by_keys_tmpl<2>(keys);
if (width == 3) return sort_by_keys_tmpl<3>(keys);
if (width == 4) return sort_by_keys_tmpl<4>(keys);
OMEGA_H_NORETURN(LOs());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
decl %edx
cmpl $0x3, %edx
ja 0x22fd19
movq %rdi, %r14
leaq 0x52f59(%rip), %rax # 0x2828c0
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0xf0580
leaq 0x52fbb(%rip), %rdi # 0x2829... | /gahansen[P]omega_h/src/Omega_h_sort.cpp |
void Omega_h::parallel_for<void Omega_h::combine_perms<int>(Omega_h::Read<int>, int, Omega_h::Write<int>, Omega_h::Write<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 0x417a2(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x40fd6(%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 |
int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::next_smallest_value<int>(Omega_h::Read<int>, int)::'lambda'(int), int, Omega_h::minimum<int>>(int, int, int, Omega_h::minimum<int>, int Omega_h::next_smallest_value<int>(Omega_h::Read<int>, int)::'lambda'(int)&&) | Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0xdb80d(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xf2060
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movl 0x10(%r15), %ecx
movslq %r14d,... | /gahansen[P]omega_h/src/Omega_h_reduce.hpp |
Omega_h::get_side_vectors(Omega_h::Mesh*, Omega_h::Read<int>) | Reals get_side_vectors(Mesh* mesh, LOs surf_side2side) {
if (mesh->dim() == 3) return get_triangle_normals(mesh, surf_side2side);
if (mesh->dim() == 2) return get_edge_normals(mesh, surf_side2side);
OMEGA_H_NORETURN(Reals());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x30(%rsp)
movq %rsi, %rdi
callq 0xfe5f0
cmpl $0x3, %eax
jne 0x23659c
leaq 0x160(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf0580
movq %r15, %rdi
movq %r12, 0x... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::get_curv_edge_tangents(Omega_h::Mesh*, Omega_h::Read<int>) | Reals get_curv_edge_tangents(Mesh* mesh, LOs curv_edge2edge) {
if (mesh->dim() == 3)
return get_curv_edge_tangents_dim<3>(mesh, curv_edge2edge);
if (mesh->dim() == 2)
return get_curv_edge_tangents_dim<2>(mesh, curv_edge2edge);
OMEGA_H_NORETURN(Reals());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
cmpl $0x3, %eax
jne 0x23709e
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf0580
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf6380
jmp 0x2370c9
movq %r14... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::tri_vert_normal_weights(Omega_h::Mesh*, Omega_h::Adj, Omega_h::Read<int>) | Reals tri_vert_normal_weights(
Mesh* mesh, Adj surf_verts2tris, LOs tri2surf_tri) {
auto nsurf_verts = surf_verts2tris.nnodes();
auto fv2v = mesh->ask_verts_of(FACE);
auto coords = mesh->coords();
auto nweights = surf_verts2tris.nedges();
auto weights = Write<Real>(nweights);
auto func = OMEGA_H_LAMBDA(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rdi
callq 0xec6d0
movl %eax, 0x18(%rsp)
leaq 0x78(%rsp), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0xf3940
leaq 0x68(%rsp), %rdi
... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::get_recip_length_weights(Omega_h::Mesh*, Omega_h::Adj, Omega_h::Read<int>) | Reals get_recip_length_weights(
Mesh* mesh, Adj surf_verts2edges, LOs edge2surf_edge) {
auto edge2len = measure_edges_real(mesh);
auto nedges = mesh->nedges();
auto edge2weight_w = Write<Real>(nedges);
auto f = OMEGA_H_LAMBDA(LO edge) {
if (edge2surf_edge[edge] == -1)
edge2weight_w[edge] = 0.0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf37c0
movq %r12, %rdi
callq 0xee2f0
movl %eax, %ebp
leaq 0x450bd(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::get_curv_edge_vert_flips(Omega_h::Mesh*, Omega_h::Adj, Omega_h::Read<int>) | Read<I8> get_curv_edge_vert_flips(
Mesh* mesh, Adj curv_verts2edges, LOs edge2curv_edge) {
auto in = get_curv_vert_edge_flips(curv_verts2edges, edge2curv_edge);
auto out = Write<I8>(mesh->nedges() * 2, I8(0));
auto ncurv_verts = curv_verts2edges.nnodes();
auto f = OMEGA_H_LAMBDA(LO curv_vert) {
for (aut... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x138(%rsp), %rdi
movq %rdx, %rsi
callq 0xee220
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0x38(%rsp), %rdi
leaq 0x138(%rsp), %r... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::get_curv_vert_curvatures(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>) | Reals get_curv_vert_curvatures(Mesh* mesh, LOs curv_edge2edge,
Reals curv_edge_curvatures, LOs curv_vert2vert) {
if (mesh->dim() == 3) {
return get_curv_vert_curvatures_dim<3>(
mesh, curv_edge2edge, curv_edge_curvatures, curv_vert2vert);
}
if (mesh->dim() == 2) {
return get_curv_vert_curvature... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xfe5f0
cmpl $0x3, %eax
jne 0x23c751
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0x48(%rsp), %r12
movq %r12... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::get_surface_info(Omega_h::Mesh*) | SurfaceInfo get_surface_info(Mesh* mesh) {
SurfaceInfo out;
if (mesh->dim() == 1) return out;
auto sdim = mesh->dim() - 1;
auto sides_are_surf = mark_by_class_dim(mesh, sdim, sdim);
auto verts_are_surf = mark_by_class_dim(mesh, VERT, sdim);
auto surf_side2side = collect_marked(sides_are_surf);
auto surf_v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x290, %rsp # imm = 0x290
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, %rdi
callq 0xf... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::Read<double> Omega_h::get_curv_vert_tangents_dim<2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>) | Reals get_curv_vert_tangents_dim(Mesh* mesh, LOs curv_edge2edge,
Reals curv_edge_tangents, LOs curv_vert2vert) {
OMEGA_H_CHECK(mesh->dim() == dim);
OMEGA_H_CHECK(mesh->owners_have_all_upward(VERT));
auto verts2edges = mesh->ask_up(VERT, EDGE);
auto curv_verts2edges = unmap_adjacency(curv_vert2vert, verts2ed... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
cmpl $0x2, %eax
jne 0x23e423
movq %r14, %rdi
xorl %esi, %esi
callq 0xec380
testb %al, %al
je 0x23e43f
... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::Read<double> Omega_h::get_curv_edge_curvatures_dim<2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Read<double>) | Reals get_curv_edge_curvatures_dim(Mesh* mesh, LOs curv_edge2edge,
Reals curv_edge_tangents, LOs curv_vert2vert, Reals curv_vert_tangents) {
auto vert2curv_vert = invert_injective_map(curv_vert2vert, mesh->nverts());
auto edge2curv_edge = invert_injective_map(curv_edge2edge, mesh->nedges());
auto edges2verts ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %r9, %rbp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
leaq 0xd8(%rsp), %r13
movq %r13, %rdi
movq %r8, %rsi
callq 0xf0580
movq %r15, %rdi
callq 0xfbde0
leaq 0xe8(%rsp... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
Omega_h::Read<double> Omega_h::get_curv_vert_curvatures_dim<2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>) | Reals get_curv_vert_curvatures_dim(Mesh* mesh, LOs curv_edge2edge,
Reals curv_edge_curvatures, LOs curv_vert2vert) {
auto verts2edges = mesh->ask_up(VERT, EDGE);
auto edges2verts = mesh->ask_verts_of(EDGE);
auto edge2curv_edge = invert_injective_map(curv_edge2edge, mesh->nedges());
auto ncurv_verts = curv_v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x188(%rsp), %rdi
pushq $0x1
popq %rbp
xorl %edx, %edx
movl %ebp, %ecx
callq 0xf2f20
leaq 0xd8(%rsp), %rdi
movq %r14, %rsi
movl... | /gahansen[P]omega_h/src/Omega_h_surface.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::get_curv_vert_tangents_dim<3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::get_curv_vert_tangents_dim<3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Rea... | 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 $0x78, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x100190
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf17f0
leaq 0x8(%rsp), %rdi
callq 0xf7130
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf7130
movq %rbx, %rdi
callq 0... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<double> Omega_h::get_curv_vert_tangents_dim<2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>)::'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 0x18(%rdi), %rcx
movq 0x38(%rdi), %rdx
movslq (%rcx,%rax,4), %rcx
movl (%rdx,%rcx,4), %ecx
cmpl $-0x1, %ecx
je 0x240725
addl %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq 0x58(%rdi), %rcx
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x2406c0
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x28(%rsp,%rdx,8)
in... | /gahansen[P]omega_h/src/Omega_h_array.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::get_curv_vert_curvatures_dim<2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h::Read<int>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::get_curv_vert_curvatures_dim<2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>, Omega_h:... | 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 $0xa8, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xfe4d0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf1d70
leaq 0x8(%rsp), %rdi
callq 0xf87e0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf87e0
movq %rbx, %rdi
callq 0x... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::filter_swap(Omega_h::Read<signed char>, Omega_h::Read<int>*, Omega_h::Read<double>*) | void filter_swap(Read<I8> keep_cands, LOs* cands2edges, Reals* cand_quals) {
auto kept2old = collect_marked(keep_cands);
*cands2edges = unmap(kept2old, *cands2edges, 1);
if (cand_quals) *cand_quals = unmap(kept2old, *cand_quals, 1);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0xf8e10
movq %rsp, %rdi
movq %r15, %rsi
callq 0xff640
leaq 0x80(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0xf0580
leaq 0x40(%rsp), %rdi
movq %r14, %rs... | /gahansen[P]omega_h/src/Omega_h_swap.cpp |
Omega_h::swap_edges(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | bool swap_edges(Mesh* mesh, AdaptOpts const& opts) {
OMEGA_H_TIME_FUNCTION;
bool ret = false;
if (mesh->dim() == 3)
ret = swap_edges_3d(mesh, opts);
else if (mesh->dim() == 2)
ret = swap_edges_2d(mesh, opts);
return ret;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x403da(%rip), %rsi # 0x282a67
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x34bf2(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x2e
popq %rsi
callq 0xf9e... | /gahansen[P]omega_h/src/Omega_h_swap.cpp |
Omega_h::Read<double> Omega_h::swap2d_qualities_tmpl<2>(Omega_h::Mesh*, Omega_h::AdaptOpts const&, Omega_h::Read<int>) | Reals swap2d_qualities_tmpl(
Mesh* mesh, AdaptOpts const& opts, LOs cands2edges) {
auto e2t = mesh->ask_up(EDGE, FACE);
auto e2et = e2t.a2ab;
auto et2t = e2t.ab2b;
auto et_codes = e2t.codes;
auto edge_verts2verts = mesh->ask_verts_of(EDGE);
auto tri_verts2verts = mesh->ask_verts_of(FACE);
auto edges_a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
leaq 0x1c8(%rsp), %rbx
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
movq %rbx, %rdi
callq 0xf2f20
leaq 0xb0(%rsp), %rdi
movq %rbx, %rsi
callq 0xf0580
... | /gahansen[P]omega_h/src/Omega_h_swap2d_qualities.cpp |
void Omega_h::parallel_for<void Omega_h::swap3d_qualities_tmpl<3>(Omega_h::Mesh*, Omega_h::AdaptOpts const&, Omega_h::Read<int>, Omega_h::Read<double>*, Omega_h::Read<signed char>*)::'lambda'(int)>(int, void Omega_h::swap3d_qualities_tmpl<3>(Omega_h::Mesh*, Omega_h::AdaptOpts const&, Omega_h::Read<int>, Omega_h::Read<d... | 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 $0xd8, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xefd40
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xfee10
movq %rsp, %rdi
callq 0xfc640
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xfc640
movq %rbx, %rdi
callq 0xff4a0
nop
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::swap3d_topology(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>, Omega_h::HostFew<Omega_h::Read<int>, 4>) | HostFew<LOs, 4> swap3d_topology(Mesh* mesh, LOs keys2edges,
Read<I8> edge_configs, HostFew<LOs, 4> keys2prods) {
auto edges2tets = mesh->ask_up(EDGE, REGION);
auto edges2edge_tets = edges2tets.a2ab;
auto edge_tets2tets = edges2tets.ab2b;
auto edge_tet_codes = edges2tets.codes;
auto edge_verts2verts = mesh... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
leaq 0x258(%rsp), %r14
pushq $0x1
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
callq 0xf2f20
leaq 0xd8(%rsp), %rdi
movq... | /gahansen[P]omega_h/src/Omega_h_swap3d_topology.cpp |
Omega_h::transfer_inherit_refine(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Read<int>, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::TagBase const*) | void transfer_inherit_refine(Mesh* old_mesh, Mesh* new_mesh, LOs keys2edges,
Int prod_dim, LOs keys2prods, LOs prods2new_ents, LOs same_ents2old_ents,
LOs same_ents2new_ents, TagBase const* tagbase) {
switch (tagbase->type()) {
case OMEGA_H_I8:
transfer_inherit_refine<I8>(old_mesh, new_mesh, keys2ed... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, %rbx
movq %r8, %r12
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq 0x1a0(%rsp), %rbp
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
cmpl $0x5, %eax
ja 0x24d472
mov... | /gahansen[P]omega_h/src/Omega_h_transfer.cpp |
Omega_h::transfer_length(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>) | void transfer_length(Mesh* old_mesh, Mesh* new_mesh, LOs same_ents2old_ents,
LOs same_ents2new_ents, LOs prods2new_ents) {
for (Int i = 0; i < old_mesh->ntags(EDGE); ++i) {
auto tagbase = old_mesh->get_tag(EDGE, i);
if (tagbase->name() == "length" && tagbase->type() == OMEGA_H_REAL &&
tagbase->nco... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %ebp, %ebp
pushq $0x1
popq %rbx
leaq 0x78(%rsp), %r15
leaq 0x68(%rsp), %r13
movq %rdi, 0x10(%rsp)
movq %r14, %rdi
movl %ebx, %esi
call... | /gahansen[P]omega_h/src/Omega_h_transfer.cpp |
Omega_h::transfer_face_flux(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>) | static void transfer_face_flux(Mesh* old_mesh, Mesh* new_mesh,
LOs same_ents2old_ents, LOs same_ents2new_ents, LOs prods2new_ents) {
for (Int i = 0; i < old_mesh->ntags(FACE); ++i) {
TagBase const* tagbase = old_mesh->get_tag(FACE, i);
if (tagbase->name() == "magnetic face flux") {
Read<Real> old_da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
xorl %r14d, %r14d
pushq $0x2
popq %rbx
leaq 0x78(%rsp), %rbp
movq %r13, %rdi
movl %ebx, %esi
callq 0xf4870
cmpl %eax, %r14d
jge 0x24f0... | /gahansen[P]omega_h/src/Omega_h_transfer.cpp |
void Omega_h::parallel_for<void Omega_h::transfer_inherit_refine<signed char>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Read<int>, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(in... | 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 $0x68, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xec1d0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xed3d0
movq %rsp, %rdi
callq 0xf5510
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf5510
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<void Omega_h::transfer_inherit_refine<int>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Read<int>, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(int)>(int, void... | 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 $0x68, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf5620
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf2ab0
movq %rsp, %rdi
callq 0xee1e0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xee1e0
movq %rbx, %rdi
callq 0xff4a0
nop
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::transfer_common2<long>(Omega_h::Mesh*, Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::TagBase const*, Omega_h::Write<long>) | void transfer_common2(Mesh* old_mesh, Mesh* new_mesh, Int ent_dim,
LOs same_ents2old_ents, LOs same_ents2new_ents, TagBase const* tagbase,
Write<T> new_data) {
auto const& name = tagbase->name();
auto ncomps = tagbase->ncomps();
auto old_data = old_mesh->get_array<T>(ent_dim, name);
auto same_data = rea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq %r9, %rdi
callq 0xf5eb0
movq %rax, %r12
movq %rbx, %rdi
callq 0xf9bc0
movl %eax, %r15d
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
mo... | /gahansen[P]omega_h/src/Omega_h_transfer.cpp |
void Omega_h::transfer_common3<double>(Omega_h::Mesh*, int, Omega_h::TagBase const*, Omega_h::Write<double>) | void transfer_common3(
Mesh* new_mesh, Int ent_dim, TagBase const* tagbase, Write<T> new_data) {
auto const& name = tagbase->name();
auto ncomps = tagbase->ncomps();
new_mesh->add_tag(ent_dim, name, ncomps, Read<T>(new_data), true);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, %rdi
callq 0xf5eb0
movq %rax, %r15
movq %r13, %rdi
callq 0xf9bc0
movl %eax, %ebp
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x8(%rsp... | /gahansen[P]omega_h/src/Omega_h_transfer.cpp |
Omega_h::unmap_owners(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>) | Remotes unmap_owners(
Mesh* old_mesh, Int ent_dim, LOs new_ents2old_ents, LOs old_ents2new_ents) {
OMEGA_H_TIME_FUNCTION;
auto old_copies2old_owners = old_mesh->ask_dist(ent_dim);
auto old_owners2old_copies = old_copies2old_owners.invert();
auto old_copies2new_owners = old_owners2old_copies.exch(old_ents2ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %r8, %r12
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2b329(%rip), %rsi # 0x2849cb
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xef870
leaq 0x1dbdd(%rip), %rdx # 0x277295
leaq ... | /gahansen[P]omega_h/src/Omega_h_unmap_mesh.cpp |
Omega_h::unmap_parents(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Read<int>*, Omega_h::Few<Omega_h::Read<int>, 4>) | void unmap_parents(Mesh* old_mesh, Mesh* new_mesh,
LOs new_ents2old_ents_a[], Few<LOs, 4> old_ents2new_ents) {
for (Int ent_dim = 1; ent_dim <= new_mesh->dim(); ++ent_dim) {
auto new_ents2old_ents = new_ents2old_ents_a[ent_dim];
auto nnew_ents = new_ents2old_ents.size();
Write<LO> new_parent_idx(nnew_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rcx, 0x50(%rsp)
movq %rdx, 0x60(%rsp)
movq %rsi, %r13
movq %rdi, 0x58(%rsp)
movl $0x80, %eax
leaq 0xe8(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
leaq 0x1b8(%rsp), %r15
leaq 0x178(%rsp), %r14
addq %... | /gahansen[P]omega_h/src/Omega_h_unmap_mesh.cpp |
Omega_h::resize_vectors(Omega_h::Read<double>, int, int) | Reals resize_vectors(Reals old_vectors, Int old_dim, Int new_dim) {
if (old_dim == new_dim) return old_vectors;
auto nv = divide_no_remainder(old_vectors.size(), old_dim);
Write<Real> new_vectors(nv * new_dim);
auto min_dim = min2(old_dim, new_dim);
auto f = OMEGA_H_LAMBDA(Int i) {
for (Int j = 0; j < min... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpl %ecx, %edx
jne 0x25aba2
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbcb0
jmp 0x25adb1
movl %ecx, %r12d
movl %edx, %r14d
movq (%r15), %rdi
testb $0x1, %dil
jne 0x25abb6
movq (%rdi), %rdi
jmp 0x25abba
shrq... | /gahansen[P]omega_h/src/Omega_h_vector.cpp |
Omega_h::Read<double> Omega_h::repeat_vector<1>(int, Omega_h::Vector<1>) | Reals repeat_vector(LO n, Vector<dim> v) {
Write<Real> vs(n * dim);
auto f = OMEGA_H_LAMBDA(LO i) { set_vector(vs, i, v); };
parallel_for(n, f, "repeat_vector");
return vs;
} | pushq %rbp
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x22643(%rip), %rsi # 0x27d4b7
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movl %ebp, %esi
callq 0xf6560
leaq 0x38(%rsp), %rdi
callq 0xf00f0
leaq 0x38(%rsp), %... | /gahansen[P]omega_h/src/Omega_h_vector.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::repeat_vector<1>(int, Omega_h::Vector<1>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::repeat_vector<1>(int, Omega_h::Vector<1>)::'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 $0x18, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xeef80
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xfe840
movq %rsp, %rdi
callq 0xfdc90
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::repeat_vector<6>(int, Omega_h::Vector<6>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::repeat_vector<6>(int, Omega_h::Vector<6>)::'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 $0x48, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xef320
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0x101180
leaq 0x8(%rsp), %rdi
callq 0xfdc90
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<double> Omega_h::repeat_vector<9>(int, Omega_h::Vector<9>) | Reals repeat_vector(LO n, Vector<dim> v) {
Write<Real> vs(n * dim);
auto f = OMEGA_H_LAMBDA(LO i) { set_vector(vs, i, v); };
parallel_for(n, f, "repeat_vector");
return vs;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x21fc5(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leal (%r14,%r14,8), %esi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xf6560
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
leaq 0x10(... | /gahansen[P]omega_h/src/Omega_h_vector.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::repeat_vector<9>(int, Omega_h::Vector<9>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::repeat_vector<9>(int, Omega_h::Vector<9>)::'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 $0x58, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf9390
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xfc2d0
movq %rsp, %rdi
callq 0xfdc90
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
| /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::Read<double> Omega_h::get_vector_norms_tmpl<2>(Omega_h::Read<double>) | Reals get_vector_norms_tmpl(Reals vs) {
auto n = divide_no_remainder(vs.size(), dim);
auto out = Write<Real>(n);
auto f = OMEGA_H_LAMBDA(LO i) { out[i] = norm(get_vector<dim>(vs, i)); };
parallel_for(n, f, "get_vector_norms");
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x25b76c
movq (%rdi), %rdi
jmp 0x25b770
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x2
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x21d32(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /gahansen[P]omega_h/src/Omega_h_vector.cpp |
Omega_h::Read<double> Omega_h::normalize_vectors_tmpl<2>(Omega_h::Read<double>) | Reals normalize_vectors_tmpl(Reals vs) {
auto n = divide_no_remainder(vs.size(), dim);
auto out = Write<Real>(vs.size());
auto f = OMEGA_H_LAMBDA(LO i) {
set_vector<dim>(out, i, normalize(get_vector<dim>(vs, i)));
};
parallel_for(n, f, "normalize_vectors");
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x25b9dd
movq (%rdi), %rdi
jmp 0x25b9e1
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x2
popq %rsi
callq 0xfd130
movl %eax, %ebp
movq (%r14), %r15
testb $0x1, %r15b
jne 0x25b9fd
movq (%r15), %r1... | /gahansen[P]omega_h/src/Omega_h_vector.cpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::get_vector_norms_tmpl<2>(Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::get_vector_norms_tmpl<2>(Omega_h::Read<double>)::'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 $0x28, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf8d10
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xed2e0
leaq 0x8(%rsp), %rdi
callq 0x101390
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101390
movq %rbx, %rdi
callq ... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::normalize_vectors_tmpl<2>(Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::normalize_vectors_tmpl<2>(Omega_h::Read<double>)::'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 $0x28, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf5fd0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0x101710
leaq 0x8(%rsp), %rdi
callq 0xf70e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf70e0
movq %rbx, %rdi
callq 0... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::dot_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::dot_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)::'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 0xf60a0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0x101200
leaq 0x8(%rsp), %rdi
callq 0xf5090
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf5090
movq %rbx, %rdi
callq 0... | /gahansen[P]omega_h/src/Omega_h_for.hpp |
Omega_h::vtk::write_p_data_array2(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int) | static void write_p_data_array2(std::ostream& stream, std::string const& name,
Int ncomps, Int Omega_h_Type) {
switch (Omega_h_Type) {
case OMEGA_H_I8:
write_p_data_array<I8>(stream, name, ncomps);
break;
case OMEGA_H_I32:
write_p_data_array<I32>(stream, name, ncomps);
break;
c... | cmpl $0x5, %ecx
ja 0x25d85f
movl %ecx, %eax
leaq 0x272ae(%rip), %rcx # 0x284af0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xf2340
jmp 0xfd460
jmp 0xf26e0
jmp 0xf4b80
retq
| /gahansen[P]omega_h/src/Omega_h_vtk.cpp |
Omega_h::vtk::write_vtkfile_vtu_start_tag(std::ostream&, bool) | void write_vtkfile_vtu_start_tag(std::ostream& stream, bool compress) {
stream << "<VTKFile type=\"UnstructuredGrid\" byte_order=\"";
if (is_little_endian_cpu())
stream << "LittleEndian";
else
stream << "BigEndian";
stream << "\" header_type=\"";
stream << Traits<std::uint64_t>::name();
stream << "\... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x27416(%rip), %rsi # 0x284cf7
callq 0xf68a0
callq 0xfea50
leaq 0x27433(%rip), %rcx # 0x284d25
leaq 0x27439(%rip), %rsi # 0x284d32
testb %al, %al
cmovneq %rcx, %rsi
movq %rbx, %rdi
callq 0xf68a0
leaq 0x2742e(%rip), %rsi # 0x284d3c
mov... | /gahansen[P]omega_h/src/Omega_h_vtk.cpp |
Omega_h::vtk::write_vtu(std::ostream&, Omega_h::Mesh*, int, std::array<std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char... | void write_vtu(std::ostream& stream, Mesh* mesh, Int cell_dim,
TagSet const& tags, bool compress) {
OMEGA_H_TIME_FUNCTION;
default_dim(mesh, &cell_dim);
verify_vtk_tagset(mesh, cell_dim, tags);
write_vtkfile_vtu_start_tag(stream, compress);
stream << "<UnstructuredGrid>\n";
write_piece_start_tag(stream,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, %ebx
movq %rcx, 0x38(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0x40(%rsp)
leaq 0x2725b(%rip), %rsi # 0x284be1
leaq 0xb8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0xef870
leaq 0x198f3(%rip), %... | /gahansen[P]omega_h/src/Omega_h_vtk.cpp |
Omega_h::vtk::read_vtu_ents(std::istream&, Omega_h::Mesh*) | void read_vtu_ents(std::istream& stream, Mesh* mesh) {
bool needs_swapping, is_compressed;
read_vtkfile_vtu_start_tag(stream, &needs_swapping, &is_compressed);
auto tag1 = xml_lite::read_tag(stream);
OMEGA_H_CHECK(tag1.elem_name == "UnstructuredGrid");
LO nverts, ncells;
read_piece_start_tag(stream, &nverts... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfabf0
leaq 0x26617(%rip), %rsi # 0x284f37
movq %r15, %rdi
callq 0x101e60
testb %al, %al
je 0x25f72b
leaq 0x26936(... | /gahansen[P]omega_h/src/Omega_h_vtk.cpp |
Omega_h::vtk::piece_filename(Omega_h::filesystem::path const&, int) | static filesystem::path piece_filename(
filesystem::path const& piecepath, I32 rank) {
auto piece_filename = piecepath;
piece_filename += '_';
piece_filename += std::to_string(rank);
piece_filename += ".vtu";
return piece_filename;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
callq 0xfabe0
pushq $0x5f
popq %rsi
movq %rbx, %rdi
callq 0xf9ae0
movq %rsp, %rdi
movl %ebp, %esi
callq 0xf9ed0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf1230
movq %rsp, %rdi
callq 0xf00f0
leaq 0x1b9f5(%rip), %rsi # 0x27ccf8
movq %rbx,... | /gahansen[P]omega_h/src/Omega_h_vtk.cpp |
Omega_h::vtk::read_pvtu(Omega_h::filesystem::path const&, std::shared_ptr<Omega_h::Comm>, int*, Omega_h::filesystem::path*, int*) | void read_pvtu(filesystem::path const& pvtupath, CommPtr comm, I32* npieces_out,
filesystem::path* vtupath_out, Int* nghost_layers_out) {
auto parentpath = pvtupath.parent_path();
std::string vtupath;
std::ifstream stream(pvtupath.c_str());
if (!stream.is_open()) {
Omega_h_fail("couldn't open \"%s\"\n",... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a0, %rsp # imm = 0x2A0
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x58(%rsp), %rdi
movq %r13, %rsi
callq 0xec840
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %... | /gahansen[P]omega_h/src/Omega_h_vtk.cpp |
Omega_h::vtk::read_pvd(std::istream&, std::vector<double, std::allocator<double>>*, std::vector<Omega_h::filesystem::path, std::allocator<Omega_h::filesystem::path>>*) | void read_pvd(std::istream& stream, std::vector<Real>* times_out,
std::vector<filesystem::path>* pvtupaths_out) {
std::vector<Real> times;
std::vector<filesystem::path> pvtupaths;
for (std::string line; std::getline(stream, line);) {
xml_lite::Tag tag;
if (!xml_lite::parse_tag(line, &tag)) continue;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
leaq 0x40(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
le... | /gahansen[P]omega_h/src/Omega_h_vtk.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.