name string | code string | asm string | file string |
|---|---|---|---|
testing::Message& testing::Message::operator<<<char [68]>(char const (&) [68]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type,
const char* a_file_name,
int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == NULL ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
m... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
addq $0x8, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x76a96
leaq ... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-test-part.h |
testing::Message& testing::Message::operator<<<char [9]>(char const (&) [9]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [35]>(char const (&) [35]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [21]>(char const (&) [21]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
ParseGoogleTestFlagsOnly(argc,... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x67050
testb $0x1, %al
jne 0x78a7b
jmp 0x78a80
jmp 0x78b1c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x78a8e
jmp 0x78b1c
leaq 0x39d73(%rip), %rdi # 0xb2808
callq 0x8d4e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
mov... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [47]>(char const (&) [47]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x721a0
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b690
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]() | std::string GetCapturedString() {
if (uncaptured_fd_ != -1) {
// Restores the original stream.
fflush(NULL);
dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_);
uncaptured_fd_ = -1;
}
FILE* const file = posix::FOpen(filename_.c_str(), "r");
const std::string content = ReadEn... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $-0x1, 0x4(%rax)
je 0x799c7
xorl %eax, %eax
movl %eax, %edi
callq 0x4b5d0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-port.cc |
void testing::internal::PrintCharAndCodeTo<unsigned char, unsigned char>(unsigned char, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << ((sizeof(c) > 1) ? "L'" : "'");
const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
//... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18ccc(%rip), %rsi # 0x92879
callq 0x4b690
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movzbl %al, %edi
callq 0x70f80
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18caa(%rip), ... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest-printers.cc |
void testing_internal::DefaultPrintNonContainerTo<long long>(long long const&, std::ostream*) | void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
// With the following statement, during unqualified name lookup,
// testing::internal2::operator<< appears as if it was declared in
// the nearest enclosing namespace that contains both
// ::testing_internal and ::testing::internal2, i.e. the... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4b6c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/gtest-printers.h |
testing::Test* testing::internal::HandleSehExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testing::Test* (testing::internal::TestFactoryBase::*)(), char const*) | Result HandleSehExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
#if GTEST_HAS_SEH
__try {
return (object->*method)();
} __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT
GetExceptionCode())) {
// We create the exception message on the h... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdx
ad... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/src/gtest.cc |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x4(%rbp), %rdi
leaq 0x10d(%rip), %rsi # 0x8b5f0
callq 0x4b9b0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x8b577
leaq 0x6944(%rip), %rdx # 0x91e40
leaq -0xc(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x81d, %ecx # imm = 0x81D
cal... | /ysshah95[P]Astar-Algorithm-for-ACME-Robotics/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
cnn::expr::squared_distance(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression squared_distance(const Expression& x, const Expression& y) { return Expression(x.pg, x.pg->add_function<SquaredEuclideanDistance>({x.i, y.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xce50c
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::CwiseQuotient>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xc0480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcefe4
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::Dropout, float&>(std::initializer_list<cnn::VariableIndex> const&, float&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments,
Args&&... side_information) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments, std::forward<Args>(side_information)...));
set_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x58
popq %rdi
callq 0xc0480
vmovss (%r12), %xmm0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq ... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::CwiseMultiply>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xc0480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcf4ba
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::KMaxPooling, unsigned int&>(std::initializer_list<cnn::VariableIndex> const&, unsigned int&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments,
Args&&... side_information) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments, std::forward<Args>(side_information)...));
set_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x58
popq %rdi
callq 0xc0480
movl (%r12), %edx
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0xc... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::Model::reset_gradient() | void Model::reset_gradient() {
for (auto p : params) { p->clear(); }
for (auto p : lookup_params) { p->clear(); }
} | pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
movq %rdi, %rbx
cmpq %r15, %r14
je 0xd21d9
movq (%r14), %rdi
addq $0x78, %rdi
callq 0x138d1c
addq $0x8, %r14
jmp 0xd21c2
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rbx
cmpq %rbx, %r14
je 0xd21f4
movq (%r14), %rdi
callq 0xd1ece
addq $0x8, %r14
jmp... | /LeonCrashCode[P]LookAheadFeature/cnn/model.cc |
cnn::Tensor::operator*() const | const Eigen::Map<Eigen::MatrixXf> operator*() const {
assert(d.batch_elems() == 1);
assert(d.ndims() < 3);
return Eigen::Map<Eigen::MatrixXf>(v, d.rows(), d.cols());
} | pushq %rbx
cmpl $0x1, 0x20(%rsi)
jne 0xd23cd
movl 0x1c(%rsi), %ecx
cmpl $0x3, %ecx
jae 0xd23e6
movq 0x28(%rsi), %rax
movl (%rsi), %edx
movq %rdi, %rbx
cmpl $0x2, %ecx
pushq $0x1
popq %rcx
cmovel 0x4(%rsi), %ecx
movq %rax, %rsi
callq 0xd297e
movq %rbx, %rax
popq %rbx
retq
leaq 0xb86e2(%rip), %rdi # 0x18aab6
leaq 0x6... | /LeonCrashCode[P]LookAheadFeature/cnn/tensor.h |
void cnn::Model::save<boost::archive::text_oarchive>(boost::archive::text_oarchive&, unsigned int) const | void save(Archive& ar, const unsigned int) const {
int np = params.size();
int nlp = lookup_params.size();
ar & np;
ar & nlp;
for (unsigned i = 0; i < params.size(); ++i)
ar & *params[i];
for (unsigned i = 0; i < lookup_params.size(); ++i)
ar & *lookup_params[i];
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x20(%rdi), %rax
movq %rsi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %r14
subq 0x18(%rdi), %rax
shrq $0x3, %rax
movl %eax, (%rsi)
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
movq %rbx, %rdi
shrq $0x3, %rax
movl %eax, (%r15)
callq 0xd3e70
movq %rbx,... | /LeonCrashCode[P]LookAheadFeature/cnn/model.h |
cnn::ConcatenateColumns::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void ConcatenateColumns::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#if HAVE_CUDA
const unsigned ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
leaq 0x20(%rsp), %r12
movq %rdi, %r15
movq %r9, %rsi
movl %r8d, %ebx
movq %rcx, %r14
movq %r12, %rdi
callq 0xd22fa
movq 0x48(%r15), %rax
movl %ebx, %ecx
movl 0x10(%r12), %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movslq (%rax,%rcx,4), %rb... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Max::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim Max::dim_forward(const vector<Dim>& xs) const {
if (xs.size() != 2 || xs[0] != xs[1]) {
cerr << "Bad arguments in Max: " << xs << endl;
throw std::invalid_argument("invalid arguments to Max");
}
return xs[0].bd >= xs[1].bd ? xs[0] : xs[1];
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
movq %rdx, %rbx
subq %rdi, %rax
cmpq $0x48, %rax
jne 0x132114
leaq 0x24(%rdi), %rsi
callq 0x136bd3
testb %al, %al
jne 0x132114
movq (%rbx), %rax
movl 0x20(%rax), %ecx
leaq 0x24(%rax), %rdx
cmpl 0x44(%rax), %ecx
cmovaeq %rax, %rdx
mo... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::SoftSign::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim SoftSign::dim_forward(const vector<Dim>& xs) const {
assert(xs.size() == 1);
if (!LooksLikeVector(xs[0])) {
ostringstream s; s << "Bad input dimensions in SoftSign: " << xs;
throw std::invalid_argument(s.str());
}
return xs[0];
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %r14
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
subq %rdi, %rax
cmpq $0x24, %rax
jne 0x134c0d
movq %rdx, %rbx
callq 0x136c0a
testb %al, %al
je 0x134c2c
movq (%rbx), %rax
movl 0x20(%rax), %ecx
movl %ecx, 0x20(%r14)
vmovups (%rax), %ymm0
m... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::LogSoftmax::as_string(std::vector<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>>>> const&) const | string LogSoftmax::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "log_softmax(" << arg_names[0] << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xc05a0
leaq 0x54c4b(%rip), %rsi # 0x189bcb
movq %r15, %rdi
callq 0xc0470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xc0410
pushq $0x29
popq %rsi
movq %rax, %rdi
callq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::PickRange::as_string(std::vector<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>>>> const&) const | string PickRange::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "slice(" << arg_names[0] << ',' << start << ':' << end << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xc05a0
leaq 0x54879(%rip), %rsi # 0x189cc6
movq %r12, %rdi
callq 0xc0470
movq (%r15), %rsi
movq %rax, %rdi
callq 0xc0410
pushq $0x2c
popq %rsi... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::BinaryLogLoss::as_string(std::vector<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>>>> const&) const | string BinaryLogLoss::as_string(const vector<string>& arg_names) const {
ostringstream os;
os << "binary_log_loss(" << arg_names[0] << ", " << arg_names[1] << ')';
return os.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xc05a0
leaq 0x5381a(%rip), %rsi # 0x18a1da
movq %r15, %rdi
callq 0xc0470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xc0410
leaq 0x52f97(%rip), %rsi # 0x189971
mov... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::TensorTools::Randomize(cnn::Tensor&, float) | void TensorTools::Randomize(Tensor& val, real scale) {
uniform_real_distribution<real> distribution(-scale,scale);
auto b = [&] {return distribution(*rndeng);};
#if HAVE_CUDA
float* t = new float[val.d.size()];
generate(t, t + val.d.size(), b);
CUDA_CHECK(cudaMemcpy(val.v, t, sizeof(real) * val.d.size(), cuda... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
vxorps 0x819f(%rip){1to4}, %xmm0, %xmm1 # 0x140edc
leaq 0x8(%rsp), %rbx
vmovss %xmm1, (%rbx)
vmovss %xmm0, 0x4(%rbx)
movq 0x28(%rdi), %r14
callq 0xc7ed2
leaq 0x80b45(%rip), %r13 # 0x1b98a0
movl %eax, %r15d
shlq $0x2, %r15
xorl %r12d, %r12d
cmpq... | /LeonCrashCode[P]LookAheadFeature/cnn/tensor.cc |
cnn::KMaxPooling::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim KMaxPooling::dim_forward(const vector<Dim>& xs) const {
if (k < 1) {
cerr << "Bad bad k in KMaxPooling: " << k << endl;
throw std::invalid_argument("bad k in KMaxPooling");
}
if (xs[0].ndims() != 2 || (xs[0].cols() < k)) {
cerr << "Bad input dimensions in KMaxPooling: " << xs << endl;
throw st... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x13aa8d
movq (%rdx), %rcx
movq %rdx, %r14
cmpl $0x2, 0x1c(%rcx)
jne 0x13aa4b
cmpl %eax, 0x4(%rcx)
jb 0x13aa4b
movl (%rcx), %ecx
leaq 0x8(%rsp), %rsi
movq %rdi, %rbx
movl %ecx, (%rsi)
movl %eax, 0x4(%rsi)
pushq $0x2
popq %rdx
ca... | /LeonCrashCode[P]LookAheadFeature/cnn/conv.cc |
main | int main( void )
{
char * endptr;
/* this, to base 36, overflows even a 256 bit integer */
char overflow[] = "-ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ_";
/* tricky border case */
char tricky[] = "+0xz";
errno = 0;
/* basic functionality */
TESTCASE( strtoull( "123", NULL, 10... | pushq %rbx
subq $0x50, %rsp
movaps 0x1e2a(%rip), %xmm0 # 0x4030
movaps %xmm0, 0x30(%rsp)
movaps 0x1e0e(%rip), %xmm0 # 0x4020
movaps %xmm0, 0x20(%rsp)
movaps 0x1df2(%rip), %xmm0 # 0x4010
movaps %xmm0, 0x10(%rsp)
movabsq $0x5f5a5a5a5a5a5a, %rax # imm = 0x5F5A5A5A5A5A5A
movq %rax, 0x3f(%rsp)
leaq 0x8(%rsp), %r... | /DevSolar[P]pdclib/functions/stdlib/strtoull.c |
PDCLIB_print_string | void _PDCLIB_print_string( const char * s, struct _PDCLIB_status_t * status )
{
if ( status->flags & E_char )
{
status->prec = 1;
}
else
{
if ( status->prec < 0 )
{
status->prec = strlen( s );
}
else
{
int i;
for ( ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %ebp
testb $0x40, %bpl
jne 0x38d9
movl 0x30(%rbx), %ecx
testl %ecx, %ecx
js 0x38de
xorl %eax, %eax
cmpq %rax, %rcx
je 0x3a02
cmpb $0x0, (%r14,%rax)
je 0x38e6
incq %rax
jmp 0x38c4
pushq $0x1
popq %rax
jmp 0x38e6
movq %r14, %rdi
callq 0x3e60... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_string.c |
PDCLIB_strtox_prelim | const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base )
{
/* skipping leading whitespace */
while ( isspace( (unsigned char)*p ) )
{
++p;
}
/* determining / skipping sign */
if ( *p != '+' && *p != '-' )
{
*sign = '+';
}
else
{
*sign... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rbx), %r12b
movzbl %r12b, %ebp
movl %ebp, %edi
callq 0x3c64
incq %rbx
testl %eax, %eax
jne 0x3b05
cmpl $0x2b, %ebp
je 0x3b2a
cmpl $0x2d, %ebp
je 0x3b2a
decq %rbx
movb $0x2b, %r12b
movb %r12b, (%r15)
cmpb $0x30,... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_strtox_prelim.c |
fputc | int fputc( int c, struct _PDCLIB_file_t * stream )
{
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
stream->buffer[stream->bufidx++] = ( char )c;
if ( ( stream->bufidx == stream->bufsize ) ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movl %edi, %ebx
leaq 0x48(%rsi), %r14
movq %r14, %rdi
callq 0x3c34
movq %r15, %rdi
callq 0x279c
cmpl $-0x1, %eax
je 0x3ec2
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r15)
movb %bl, (%rax,%rcx)
movq 0x18(%r15), %rax
cmpq 0x10(%r15), %... | /DevSolar[P]pdclib/functions/stdio/fputc.c |
ga_acc_ | void FATR ga_acc_(Integer *g_a, Integer *ilo, Integer *ihi,
Integer *jlo, Integer *jhi, void *buf, Integer *ld,
void *alpha)
{
Integer lo[2], hi[2];
lo[0]=*ilo;
lo[1]=*jlo;
hi[0]=*ihi;
hi[1]=*jhi;
wnga_acc(*g_a, lo, hi, buf, ld, alpha);
} | subq $0x28, %rsp
movq %r9, %r10
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %r9
movq (%rsi), %r11
leaq 0x10(%rsp), %rsi
movq %r11, (%rsi)
movq (%rcx), %rcx
movq %rcx, 0x8(%rsi)
movq (%rdx), %rcx
movq %rsp, %rdx
movq %rcx, (%rdx)
movq (%r8), %rcx
movq %rcx, 0x8(%rdx)
movq (%rdi), %rdi
movq %r10, %rcx
movq %rax, %r8
callq 0x6... | /GlobalArrays[P]ga/global/src/fapi.c |
nga_sdot_patch_ | Real nga_sdot_patch_(Integer *g_a, char *t_a, int alen, Integer *alo, Integer *ahi, Integer *g_b, char *t_b, int blen, Integer *blo, Integer *bhi)
#endif
{
Real retval;
Integer atype, btype;
pnga_inquire_type(*g_a, &atype);
pnga_inquire_type(*g_b, &btype);
if (atype != btype || atype != C_FLOAT) pn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
movq (%rdi), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x6654b
movq (%r13), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6654b
cmpq $0x3eb, (... | /GlobalArrays[P]ga/global/src/fapi.c |
ga_cadd_patch_ | void FATR ga_cadd_patch_(SingleComplex *alpha, Integer *g_a, Integer *ailo, Integer *aihi, Integer *ajlo, Integer *ajhi, SingleComplex *beta, Integer *g_b, Integer *bilo, Integer *bihi, Integer *bjlo, Integer *bjhi, Integer *g_c, Integer *cilo, Integer *cihi, Integer *cjlo, Integer *cjhi)
{
Integer atype, btype, ct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r13
movq 0xa0(%rsp), %r15
movq 0x78(%rsp), %r14
movq (%rsi), %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x6654b
movq (%r14),... | /GlobalArrays[P]ga/global/src/fapi.c |
nga_zadd_patch_ | void FATR nga_zadd_patch_(DoubleComplex *alpha, Integer *g_a, Integer *alo, Integer *ahi, DoubleComplex *beta, Integer *g_b, Integer *blo, Integer *bhi, Integer *g_c, Integer *clo, Integer *chi)
{
Integer atype, btype, ctype;
pnga_inquire_type(*g_a, &atype);
pnga_inquire_type(*g_b, &btype);
pnga_inquir... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq %rdi, %r13
movq 0x80(%rsp), %r15
movq (%rsi), %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x6654b
movq (%r12), %rdi
leaq 0x28(%rsp),... | /GlobalArrays[P]ga/global/src/fapi.c |
pnga_elem_divide | void pnga_elem_divide(Integer g_a, Integer g_b, Integer g_c){
Integer atype, andim;
Integer btype, bndim;
Integer ctype, cndim;
Integer alo[MAXDIM],ahi[MAXDIM];
Integer blo[MAXDIM],bhi[MAXDIM];
Integer clo[MAXDIM],chi[MAXDIM];
pnga_inquire(g_a, &atype, &andim, ahi);
pnga_inquire(g_b, &bt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %r13
leaq 0xf0(%rsp), %rcx
movq %r13, %rdx
callq 0x6645f
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rbp
leaq 0x70(%rsp), %rcx
mo... | /GlobalArrays[P]ga/global/src/elem_alg.c |
pnga_step_bound_info_patch | void pnga_step_bound_info_patch(
Integer g_xx, Integer *xxlo, Integer *xxhi, /* patch of g_xx */
Integer g_vv, Integer *vvlo, Integer *vvhi, /* patch of g_vv */
Integer g_xxll, Integer *xxlllo, Integer *xxllhi, /* patch of g_xxll */
Integer g_xxuu, Integer *xxuulo, Integer *xxuuhi, /* pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %r9, 0x60(%rsp)
movq %r8, %r13
movq %rcx, %r14
movq %rdx, 0xb8(%rsp)
movq %rsi, %rbx
movq %rdi, 0x68(%rsp)
xorl %eax, %eax
callq 0x68196
movq %rax, 0x10(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF... | /GlobalArrays[P]ga/global/src/elem_alg.c |
pnga_lu_solve_seq | void pnga_lu_solve_seq(char *trans, Integer g_a, Integer g_b) {
logical oactive; /* true iff this process participates */
Integer dimA1, dimA2, typeA;
Integer dimB1, dimB2, typeB;
Integer me;
#if HAVE_LAPACK || ENABLE_F77
BlasInt blas_dimA1, blas_dimA2, blas_dimB1, blas_dimB2, info=0;
#else
Integer info=0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, 0x40(%rsp)
movq $0x0, 0x10(%rsp)
xorl %eax, %eax
callq 0x68196
movq %rax, %r12
leaq 0xa2875(%rip), %rsi # 0xb1fb0
movq %r15, %rdi
callq 0x5cf63
leaq 0xa2875(%rip), %rsi # 0xb1fbf
movq %r... | /GlobalArrays[P]ga/global/src/ga_solve_seq.c |
pnga_symmetrize | void pnga_symmetrize(Integer g_a) {
DoublePrecision alpha = 0.5;
Integer i, me = pnga_nodeid();
Integer alo[GA_MAX_DIM], ahi[GA_MAX_DIM], lda[GA_MAX_DIM], nelem=1;
Integer blo[GA_MAX_DIM], bhi[GA_MAX_DIM], ldb[GA_MAX_DIM];
Integer ndim, dims[GA_MAX_DIM], type;
Logical have_data;
Integer g_b; /* tempora... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
xorl %eax, %eax
callq 0x68196
movq %rax, %r14
movq $0x0, 0x18(%rsp)
leaq 0xc774e(%rip), %rax # 0xd7160
leaq 0xc774b(%rip), %rcx # 0xd7164
cmpl $0x0, (%rax)
movl (%rcx), %ebp
movl $0x1, %e... | /GlobalArrays[P]ga/global/src/ga_symmetr.c |
pnga_dot | void pnga_dot(int Type, Integer g_a, Integer g_b, void *value)
{
Integer ndim=0, type=0, atype=0, me=0, elems=0, elemsb=0;
register Integer i=0;
int isum=0;
long lsum=0;
long long llsum=0;
DoubleComplex zsum ={0.,0.};
SingleComplex csum ={0.,0.};
float fsum=0.0;
void *ptr_a=NULL, *ptr_b=NULL;
int alen=0;
Integer a_grp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, 0x28(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x8(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
leaq 0xc65d8(%rip), %rax # 0xd7160... | /GlobalArrays[P]ga/global/src/global.nalg.c |
pnga_comp_patch | logical pnga_comp_patch(Integer andim, Integer *alo, Integer *ahi,
Integer bndim, Integer *blo, Integer *bhi)
{
Integer i;
Integer ndim;
if(andim > bndim) {
ndim = bndim;
for(i=ndim; i<andim; i++)
if(alo[i] != ahi[i]) return FALSE;
}
else if... | cmpq %rcx, %rdi
jle 0x123ad
xorl %eax, %eax
movq %rcx, %r10
movq (%rsi,%r10,8), %r11
cmpq (%rdx,%r10,8), %r11
jne 0x123ee
incq %r10
cmpq %r10, %rdi
jne 0x12396
movq %rcx, %rdi
jmp 0x123c6
jge 0x123c6
xorl %eax, %eax
movq %rdi, %r10
movq (%r8,%r10,8), %r11
cmpq (%r9,%r10,8), %r11
jne 0x123ee
incq %r10
cmpq %r10, %rcx
jn... | /GlobalArrays[P]ga/global/src/global.npatch.c |
pnga_error | void pnga_error(char *string, Integer icode)
{
#ifndef ARMCI
extern void Error();
#endif
#define FOUT stderr
#define ERR_LEN 400
int level;
char error_buffer[ERR_LEN];
/* JAD 02/23/2012 for applications, an exit/error code of 0 indicates
* success, it is therefore wrong to call pnga_error with a zero... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x68196
leaq 0x9a2c1(%rip), %rsi # 0xb2fff
movq %rsp, %r15
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x30a0
movq %r15, %rdi
movq %r14, %rsi
callq 0... | /GlobalArrays[P]ga/global/src/global.util.c |
pnga_print_file | void pnga_print_file(FILE *file, Integer g_a)
{
Integer i;
Integer type, ndim, dims[MAXDIM];
Integer lo[MAXDIM];
Integer pretty = 1;
pnga_inquire(g_a, &type, &ndim, dims);
for(i=0; i<ndim; i++) lo[i] = 1;
pnga_print_patch_file(file, g_a, lo, dims, pretty);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movq %rsp, %r15
leaq 0x50(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6645f
movq (%r15), %rcx
testq %rcx, %rcx
jle 0x1b186
leaq 0x1(%rcx), %rax
andq $-0x2, %rax
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, ... | /GlobalArrays[P]ga/global/src/global.util.c |
pnga_matmul | void pnga_matmul(transa, transb, alpha, beta,
g_a, ailo, aihi, ajlo, ajhi,
g_b, bilo, bihi, bjlo, bjhi,
g_c, cilo, cihi, cjlo, cjhi)
Integer g_a, ailo, aihi, ajlo, ajhi; /* patch of g_a */
Integer g_b, bilo, bihi, bjlo, bjhi; /* patch of g_b */
Integer g_c, cilo, cihi,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10618, %rsp # imm = 0x10618
movq %r9, 0xd8(%rsp)
movq %r8, %r14
movq %rcx, 0x30(%rsp)
movq %rdx, 0x180(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdi, 0xe8(%rsp)
movq 0x10690(%rsp), %r12
movq 0x10668(%rsp), %rbx
xorl %ebp, %ebp
xorl %eax, %eax
ca... | /GlobalArrays[P]ga/global/src/matmul.c |
pnga_matmul_basic | void pnga_matmul_basic(char *transa, char *transb, void *alpha, void *beta,
Integer g_a, Integer alo[], Integer ahi[],
Integer g_b, Integer blo[], Integer bhi[],
Integer g_c, Integer clo[], Integer chi[])
{
Integer atype, btype, ctype;
Integer adims[GA_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6c8, %rsp # imm = 0x6C8
movq %r9, 0x20(%rsp)
movq %r8, 0x88(%rsp)
movq %rcx, %rbp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movsd 0x8f885(%rip), %xmm0 # 0xb1120
movaps %xmm0, 0xc0(%rsp)
movss 0x8fc19(%rip), %... | /GlobalArrays[P]ga/global/src/matmul.c |
pnga_matmul_mirrored | void pnga_matmul_mirrored(transa, transb, alpha, beta,
g_a, ailo, aihi, ajlo, ajhi,
g_b, bilo, bihi, bjlo, bjhi,
g_c, cilo, cihi, cjlo, cjhi)
Integer g_a, ailo, aihi, ajlo, ajhi; /* patch of g_a */
Integer g_b, bilo, bihi, bjlo, bjhi; /* patch of g_b */
Integer g_c, cilo, cihi, cjlo, cjhi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, 0x88(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
xorl %eax, %eax
callq 0x68196
movq %rax, %r14
movsd 0x8ed9a(%rip), %xmm0 # 0xb1... | /GlobalArrays[P]ga/global/src/matmul.c |
gai_setup_2d_patch | static void gai_setup_2d_patch(Integer rank, char *trans, Integer dims[],
Integer lo[], Integer hi[],
Integer* ilo, Integer* ihi,
Integer* jlo, Integer* jhi,
Integer* dim1, Integer* dim2,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq 0x88(%rsp), %r8
movq 0x80(%rsp), %rbx
movq 0x78(%rsp), %r12
xorl %eax, %eax
testq %rdi, %rdi
jle 0x24ec3
movq %r9, (%rsp)
movq %rdx, 0x8(%rsp)
leaq 0x8ece6(%rip), ... | /GlobalArrays[P]ga/global/src/matmul.c |
sgai_median_patch_values | static void sgai_median_patch_values(Integer type, Integer ndim, Integer *loA,
Integer *hiA, Integer *ldA, void *A_ptr,
void *B_ptr, void *C_ptr, void *M_ptr,
Integer offset)
{
Integer bvalue[MAXDIM], bunit[MAXDIM], baseldA[MAXD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r9, 0x18(%rsp)
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movl $0x1, %eax
movl $0x1, %r12d
cmpq $0x2, %rsi
jl 0x265e0
movl $0x1, %ecx
movq (%r14,%rcx,8), %rdx
subq (%r15... | /GlobalArrays[P]ga/global/src/matrix.c |
pnga_shift_diagonal | void pnga_shift_diagonal(Integer g_a, void *c)
{
Integer loA[2], hiA[2]/*, dim1, dim2*/, ld;
Integer andim, adims[2], type, atype;
Integer me = pnga_nodeid (), i, nproc = pnga_nnodes();
char *ptr;
Integer num_blocks_a;
int local_sync_begin,local_sync_end;
_iterator_hdl hdl;
local_sync_begin = _ga_sync_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
callq 0x68196
xorl %eax, %eax
callq 0x681d2
leaq 0xadea5(%rip), %rax # 0xd7160
leaq 0xadea2(%rip), %rcx # 0xd7164
cmpl $0x0, (%rax)
movl (%rcx), %edx
movl ... | /GlobalArrays[P]ga/global/src/matrix.c |
pnga_lu_solve_alt | void pnga_lu_solve_alt(Integer tran, Integer g_a, Integer g_b) {
#if HAVE_SCALAPACK
# if ENABLE_F77
void gai_lu_solve_alt_(Integer *tran, Integer *g_a, Integer *g_b);
gai_lu_solve_alt_(&tran, &g_a, &g_b);
# else
pnga_error("ga_lu_solve:scalapack interfaced, need configure --enable-f77",0L);
# endif
#e... | leaq 0x8a766(%rip), %rdi # 0xb48c5
xorl %esi, %esi
jmp 0x18d1b
| /GlobalArrays[P]ga/global/src/sclstubs.c |
pnga_llt_solve | Integer pnga_llt_solve(Integer g_a, Integer g_b) {
#if HAVE_SCALAPACK
# if ENABLE_F77
Integer gai_llt_solve_(Integer *g_a, Integer *g_b);
return gai_llt_solve_(&g_a, &g_b);
# else
pnga_error("ga_lu_solve:scalapack interfaced, need configure --enable-f77",0L);
return FALSE;
# endif
#else
pnga_e... | pushq %rax
leaq 0x8a6a6(%rip), %rdi # 0xb48c5
xorl %esi, %esi
callq 0x18d1b
xorl %eax, %eax
popq %rcx
retq
| /GlobalArrays[P]ga/global/src/sclstubs.c |
pnga_bin_sorter | void pnga_bin_sorter(Integer g_bin, Integer g_cnt, Integer g_off)
{
Integer nbin,totbin,type,ndim,lo,hi,me=pnga_nodeid(),crap;
Integer g_range;
if(FALSE==pnga_create_bin_range(g_bin, g_cnt, g_off, &g_range))
pnga_error("ga_bin_sorter: failed to create temp bin range array",0);
pnga_inquire(g_bin, &ty... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
callq 0x68196
movq %rax, %r15
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x397a2
testq %rax, %rax
jne 0x39b69
leaq 0x7bac7(%rip), %rdi # 0xb5629
xo... | /GlobalArrays[P]ga/global/src/sparse.c |
pnga_sprs_array_create | Integer pnga_sprs_array_create(Integer idim, Integer jdim, Integer type, Integer size)
{
Integer i, hdl, s_a;
int local_sync_begin,local_sync_end;
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
if (local_sync_begin) pnga_p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9cdcf(%rip), %rax # 0xd7160
leaq 0x9cdcc(%rip), %rcx # 0xd7164
cmpl $0x0, (%rax)
movl (%rcx), %edx
movl %edx, 0x4(%rsp)
movl $0x1, %edx
movl %edx, (%rax)... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_column_distribution | void pnga_sprs_array_column_distribution(Integer s_a, Integer iproc, Integer *lo,
Integer *hi)
{
Integer hdl = GA_OFFSET + s_a;
Integer nproc = SPA[hdl].nprocs;
Integer jdim = SPA[hdl].jdim;
*lo = (SPA[hdl].jdim*iproc)/nproc;
while (((*lo)*nproc)/jdim < iproc) {
(*lo)++;
}
while (((*lo)*nproc)/jdi... | pushq %r14
pushq %rbx
movq %rdx, %r8
leaq 0x9fea7(%rip), %rax # 0xdc0c0
movq (%rax), %rax
imulq $0xc8, %rdi, %rdx
movq 0x30d48(%rax,%rdx), %r11
movq 0x30d90(%rax,%rdx), %rbx
movq %r11, %rax
imulq %rsi, %rax
cqto
idivq %rbx
movq %rax, %r9
leaq -0x1(%rax), %r14
movq %rbx, %r10
imulq %r14, %r10
leaq -0x2(%rax), %rdi
i... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_matvec_multiply | void pnga_sprs_array_matvec_multiply(Integer s_a, Integer g_a, Integer g_v)
{
Integer s_hdl = GA_OFFSET + s_a;
int local_sync_begin,local_sync_end;
Integer s_grp = SPA[s_hdl].grp;
Integer me = pnga_pgroup_nodeid(s_grp);
Integer nproc = pnga_pgroup_nnodes(s_grp);
Integer ilo, ihi, jlo, jhi, klo, khi;
void... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %r12
movq %rsi, 0x28(%rsp)
movq %rdi, (%rsp)
leaq 0x3e8(%rdi), %rax
leaq 0x9f97a(%rip), %r14 # 0xdc0c0
movq (%r14), %rcx
imulq $0xc8, %rax, %r15
movq 0x38(%rcx,%r15), %rbx
movq %rbx, %rdi
callq 0x... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_destroy | logical pnga_sprs_array_destroy(Integer s_a)
{
Integer hdl = GA_OFFSET + s_a;
Integer ret = 1;
int local_sync_begin,local_sync_end;
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
if (local_sync_begin) pnga_pgroup_sync(SPA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x3e8, %rbx # imm = 0x3E8
leaq 0x9984c(%rip), %rax # 0xd7160
leaq 0x99849(%rip), %rcx # 0xd7164
cmpl $0x0, (%rax)
movl (%rcx), %ebp
movl $0x1, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
je 0x3d946
leaq 0x... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_diag_left_multiply | void pnga_sprs_array_diag_left_multiply(Integer s_a, Integer g_d)
{
Integer hdl = GA_OFFSET + s_a;
Integer d_hdl = GA_OFFSET + g_d;
int local_sync_begin,local_sync_end;
Integer grp = SPA[hdl].grp;
Integer me = pnga_pgroup_nodeid(grp);
Integer nproc = pnga_pgroup_nnodes(grp);
Integer ilo, ihi, jlo, jhi, kl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movl $0x3e8, %r13d # imm = 0x3E8
leaq (%rdi,%r13), %rax
movq %rsi, 0x30(%rsp)
addq %rsi, %r13
leaq 0x9d617(%rip), %rbx # 0xdc0c0
movq (%rbx), %rcx
imulq $0xc8, %rax, %r12
movq 0x38(%rcx,%r12), %rbp
movq %rbp... | /GlobalArrays[P]ga/global/src/sparse.array.c |
update_map | void update_map(Integer **top, Integer **list, Integer **idx, Integer **jdx,
void **data, Integer idim, Integer jdim, Integer elemsize,
Integer *bufsize, Integer *ncnt)
{
Integer *ttop;
Integer *tlist;
Integer *tidx, *tjdx;
Integer lcnt;
Integer newsize;
void *tdata;
char *nptr;
char *optr;
In... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movq 0xe0(%rsp), %rax
movq (%rax), %rbp
leaq (,%rbp,2), %r15
movq %rbp, %r14
shlq $0x4, %r14
movq %r14, %rdi
callq 0x33b0
movq %rax, %... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_dnssprs_multiply | Integer pnga_sprs_array_dnssprs_multiply(Integer g_a, Integer s_b, Integer trans)
{
Integer lcnt;
Integer icnt;
Integer hdl_a = g_a+GA_OFFSET;
Integer hdl_b = s_b+GA_OFFSET;
Integer hdl_c;
int local_sync_begin,local_sync_end;
Integer elemsize;
Integer idim, jdim;
Integer i, j, k, l, m, n, nn;
Intege... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, 0x10(%rsp)
movl $0x3e8, %eax # imm = 0x3E8
movq %rdi, 0x168(%rsp)
leaq (%rdi,%rax), %r15
movq %rsi, 0x150(%rsp)
addq %rsi, %rax
leaq 0x9616e(%rip), %r12 # 0xdc0c0
movq (%r12), %rcx
imul... | /GlobalArrays[P]ga/global/src/sparse.array.c |
MA_inquire_avail | public Integer MA_inquire_avail(Integer datatype)
{
size_t gap_length; /* # of bytes between heap and stack */
Integer nelem_gap; /* max elements containable in gap */
#ifdef STATS
ma_stats.calls[(int)FID_MA_inquire_avail]++;
#endif /* STATS */
#ifdef VERIFY
if (ma_auto_verify && !MA_verif... | pushq %rbx
incq 0x860b6(%rip) # 0xdc180
cmpb $0x0, 0x85fff(%rip) # 0xdc0d0
je 0x560f9
movq %rdi, %rax
leaq -0x3e8(%rdi), %rdx
cmpq $0x11, %rdx
jae 0x56128
movq 0x8615e(%rip), %rsi # 0xdc248
movq 0x8614f(%rip), %rdi # 0xdc240
subq %rdi, %rsi
je 0x56156
popq %rbx
jmp 0x5615a
movups 0x60e56(%rip), %x... | /GlobalArrays[P]ga/ma/ma.c |
ma_max_heap_frag_nelem | private Integer ma_max_heap_frag_nelem(datatype, min_nelem)
Integer datatype; /* of elements */
Integer min_nelem; /* for fragment to be considered */
{
ulongi min_bytes; /* for fragment to be considered */
AD *ad; /* traversal pointer */
ulongi nbytes; /* i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x85f81(%rip), %r14 # 0xdc238
testq %r14, %r14
je 0x56318
movq %rdi, %rbx
leaq 0x80e2a(%rip), %rax # 0xd70f0
movslq (%rax,%rdi,4), %r12
imulq %rsi, %r12
addq $0x58, %r12
movq 0x85f87(%rip), %r13 # 0xdc260
xorl %r15d, %r15d
cmpq %r13, %r14
jae 0x563... | /GlobalArrays[P]ga/ma/ma.c |
MA_inquire_stack | public Integer MA_inquire_stack(Integer datatype)
{
size_t gap_length; /* # of bytes between partition and stack */
Integer nelem_gap; /* max elements containable in gap */
#ifdef STATS
ma_stats.calls[(int)FID_MA_inquire_stack]++;
#endif /* STATS */
#ifdef VERIFY
if (ma_auto_verify && !MA_... | pushq %rbx
incq 0x85cde(%rip) # 0xdc1a0
cmpb $0x0, 0x85c07(%rip) # 0xdc0d0
je 0x564f4
movq %rdi, %rax
leaq -0x3e8(%rdi), %rdx
cmpq $0x11, %rdx
jae 0x56523
movq 0x85d66(%rip), %rsi # 0xdc248
movq 0x85d77(%rip), %rdi # 0xdc260
subq %rdi, %rsi
je 0x56551
popq %rbx
jmp 0x5615a
movups 0x60a5b(%rip), %x... | /GlobalArrays[P]ga/ma/ma.c |
MA_set_auto_verify | public Boolean MA_set_auto_verify(Boolean value /* to set flag to */)
{
Boolean old_value; /* of flag */
#ifdef STATS
ma_stats.calls[(int)FID_MA_set_auto_verify]++;
#endif /* STATS */
old_value = ma_auto_verify;
ma_auto_verify = value;
return old_value;
} | incq 0x855c6(%rip) # 0xdc1d8
movq 0x85657(%rip), %rax # 0xdc270
movq %rdi, 0x85650(%rip) # 0xdc270
retq
| /GlobalArrays[P]ga/ma/ma.c |
MA_set_hard_fail | public Boolean MA_set_hard_fail( Boolean value /* to set flag to */)
{
Boolean old_value; /* of flag */
#ifdef STATS
ma_stats.calls[(int)FID_MA_set_hard_fail]++;
#endif /* STATS */
old_value = ma_hard_fail;
ma_hard_fail = value;
return old_value;
} | incq 0x855ab(%rip) # 0xdc1e8
leaq 0x8572c(%rip), %rcx # 0xdc370
movq (%rcx), %rax
movq %rdi, (%rcx)
retq
| /GlobalArrays[P]ga/ma/ma.c |
ma_table_verify | public Boolean ma_table_verify(handle, caller)
Integer handle; /* to verify */
char *caller; /* name of calling routine */
{
Boolean badhandle; /* is handle invalid? */
badhandle = MA_FALSE;
/* if handle is invalid, construct an error message */
if ((handle < 0) ||
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0x606c8(%rip), %rsi # 0xb7952
testq %rdi, %rdi
js 0x572c0
cmpq %rdx, 0x854f2(%rip) # 0xdc788
jle 0x572c0
movq 0x854f1(%rip), %rax # 0xdc790
movq %rdx, %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %eax
testl %eax, %eax
je 0x572c0
movl $0x1, %... | /GlobalArrays[P]ga/ma/table.c |
ma_table_lookup_assoc | public Integer ma_table_lookup_assoc(data)
TableData data; /* to lookup */
{
Integer i;
/* perform a linear search from the first table slot */
for (i = 0; i < ma_table_capacity; i++)
if ((ma_table[i].state == TES_Allocated) && (ma_table[i].data == data))
/* success */
... | movq 0x85468(%rip), %rcx # 0xdc788
movq $-0x1, %rax
testq %rcx, %rcx
jle 0x57350
movq 0x8545d(%rip), %rdx # 0xdc790
addq $0x8, %rdx
xorl %esi, %esi
cmpl $0x1, (%rdx)
jne 0x57344
cmpq %rdi, -0x8(%rdx)
je 0x57351
incq %rsi
addq $0x10, %rdx
cmpq %rsi, %rcx
jne 0x57339
retq
movq %rsi, %rax
retq
nopl (%rax)
| /GlobalArrays[P]ga/ma/table.c |
ga_f2c_get_cmd_args | void ga_f2c_get_cmd_args(int *argc, char ***argv)
{
Integer i=0;
int iargc=F2C_IARGC();
char **iargv=NULL;
if (iargc > F2C_GETARG_ARGV_MAX) {
printf("ga_f2c_get_cmd_args: too many cmd line args");
armci_msg_abort(1);
}
iargv = (char**)malloc(sizeof(char*)*F2C_GETARG_ARGV_MAX);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq $0x0, (%rsp)
xorl %eax, %eax
callq 0x57790
movq %rax, %rbx
cmpl $0x100, %ebx # imm = 0x100
jl 0x57691
leaq 0x60309(%rip), %rdi # 0xb7989
xorl %eax,... | /GlobalArrays[P]ga/gaf2c/gaf2c.c |
PARMCI_NbPutV | int PARMCI_NbPutV(armci_giov_t *darr, int len, int proc, armci_hdl_t *nb_handle)
{
int rc;
comex_giov_t *adarr = malloc(sizeof(comex_giov_t) * len);
convert_giov(darr, adarr, len);
rc = comex_nbputv(adarr, len, proc, COMEX_GROUP_WORLD, nb_handle);
free(adarr);
return rc;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r12
movslq %esi, %r13
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x33b0
movq %rax, %r15
testl %r13d, %r13d
jle 0x58699
movl %r14d, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %... | /GlobalArrays[P]ga/comex/src-armci/armci.c |
armci_msg_rcvany | int armci_msg_rcvany(int tag, void* buffer, int len, int *msglen)
{
MPI_Comm comm = wc();
MPI_Request request;
MPI_Status status;
int rank;
int flag = 0;
int rc;
rc = MPI_Comm_rank(comm, &rank);
assert(MPI_SUCCESS == rc);
#if COMEX_NETWORK_MPI_TS
assert(COMEX_TAG != tag);
#endif
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %ebp
callq 0x5a05d
movl $0x0, 0x14(%rsp)
leaq 0x24(%rsp), %rsi
movq %rax, %rdi
callq 0x3410
testl %eax, %eax
jne 0x594e5
cmpl $0x6be8, %ebp # imm = 0x6BE8
je 0x59504
callq 0x5a05... | /GlobalArrays[P]ga/comex/src-armci/message.c |
armci_msg_bintree | void armci_msg_bintree(int scope, int* Root, int *Up, int *Left, int *Right)
{
int root, up, left, right, index, nproc;
assert(SCOPE_NODE != scope);
assert(SCOPE_MASTERS != scope);
root = 0;
nproc = armci_msg_nproc();
index = armci_msg_me() - root;
up = (index-1)/2 + root; if( up < roo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x153, %edi # imm = 0x153
je 0x59bdc
cmpl $0x151, %edi # imm = 0x151
je 0x59bfb
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
callq 0x59c93
movl %eax, %ebp
callq 0x59c1a
leal -0x1(%rax), %ecx
shrl $0x1f, %ecx
addl %eax, ... | /GlobalArrays[P]ga/comex/src-armci/message.c |
armci_msg_me | int armci_msg_me()
{
int rank;
assert(comex_initialized());
assert(wc() != MPI_COMM_NULL);
MPI_Comm_rank(wc(), &rank);
return rank;
} | pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
callq 0x5bfbc
testl %eax, %eax
je 0x59c55
callq 0x5a05d
cmpq 0x7d352(%rip), %rax # 0xd6f88
je 0x59c74
callq 0x5a05d
leaq 0xc(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3410
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x5e14f(%rip), %rdi # 0xb7dab
l... | /GlobalArrays[P]ga/comex/src-armci/message.c |
my_malloc | static void* _my_malloc(size_t size)
{
void *memptr=NULL;
memptr = malloc(size);
assert(memptr);
#if MEMSET_AFTER_MALLOC
/* valgrind was reporting uninitialized values coming from _my_malloc
* so use this memset to quiet valgrind for now. We may turn this
* off after additional development/te... | pushq %rax
callq 0x33b0
testq %rax, %rax
je 0x5aa65
popq %rcx
retq
leaq 0x5e0cd(%rip), %rdi # 0xb8b39
leaq 0x5db2f(%rip), %rsi # 0xb85a2
leaq 0x5e0c6(%rip), %rcx # 0xb8b40
movl $0x94, %edx
callq 0x3180
| /GlobalArrays[P]ga/comex/src-mpi/comex.c |
comex_fence_proc | int comex_fence_proc(int proc, comex_group_t group)
{
int *notify = NULL;
CHECK_GROUP(group,proc);
#if DEBUG
printf("[%d] comex_fence_proc(proc=%d,group=$d)\n",
l_state.rank, proc, group);
#endif
/* Corner case */
if (proc == l_state.rank) {
return COMEX_SUCCESS;
}
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movq %rsp, %rsi
movl %ebp, %edi
callq 0x5cb6c
testl %eax, %eax
jne 0x5b845
testl %ebx, %ebx
js 0x5b84e
cmpl %ebx, (%rsp)
jle 0x5b857
testl %ebp, %ebp
je 0x5b7dd
leaq 0x4(%rsp), %r14
movl %ebp, %edi
movl %ebx, %esi
movq %r14, %rdx
cal... | /GlobalArrays[P]ga/comex/src-mpi/comex.c |
pnga_pgroup_create | Integer pnga_pgroup_create(Integer *list, Integer count)
{
Integer pgrp_handle, i, j, nprocs, itmp;
Integer parent;
int tmp_count;
Integer *tmp_list;
int *tmp2_list;
#ifdef MSG_COMMS_MPI
ARMCI_Group *tmpgrp;
#endif
/* Allocate temporary arrays */
tmp_list = (Integer*)malloc(GAnproc*si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x7f2d0(%rip), %rax # 0xdc998
movq (%rax), %r15
leaq (,%r15,8), %rdi
callq 0x33b0
movq %rax, 0x8(%rsp)
shlq $0x2, %r15
movq %r15, %rdi
callq 0x33b0
movq %rax, %r15
leaq 0x7f21d(%rip), %rax # 0... | /GlobalArrays[P]ga/global/src/base.c |
pnga_is_mirrored | logical pnga_is_mirrored(Integer g_a)
{
Integer ret = FALSE;
Integer handle = GA_OFFSET + g_a;
Integer p_handle = (Integer)GA[handle].p_handle;
if (p_handle >= 0) {
if (PGRP_LIST[p_handle].mirrored) ret = TRUE;
}
return ret;
} | leaq 0x7ee7f(%rip), %rax # 0xdc8b8
movq (%rax), %rax
imulq $0x368, %rdi, %rcx # imm = 0x368
movslq 0xd5050(%rax,%rcx), %rax
testq %rax, %rax
js 0x5da68
leaq 0x7eeb9(%rip), %rcx # 0xdc910
movq (%rcx), %rcx
leaq (%rax,%rax,4), %rdx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdx,8)
setne %al
retq
xorl %eax, %eax
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_proc_topology | void pnga_proc_topology(Integer g_a, Integer proc, Integer* subscript)
{
Integer d, index, ndim, ga_handle = GA_OFFSET + g_a;
ga_check_handleM(g_a, "nga_proc_topology");
ndim = GA[ga_handle].ndim;
index = proc;
for(d=0; d<ndim; d++){
subscript[d] = index% GA[ga_handle].nblock[d];
index /= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3e8(%rdi), %r13
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x5f03a
leaq 0x78136(%rip), %rax # 0xd7168
movslq (%rax), %rax
cmpq %rax, %r13
jl 0x5f060... | /GlobalArrays[P]ga/global/src/base.c |
pnga_set_restricted | void pnga_set_restricted(Integer g_a, Integer *list, Integer size)
{
Integer i, ig, id=0, me, p_handle, has_data, nproc;
Integer ga_handle = g_a + GA_OFFSET;
GA[ga_handle].num_rstrctd = size;
GA[ga_handle].rstrctd_list = (Integer*)malloc(size*sizeof(Integer));
GA[ga_handle].rank_rstrctd = (Integer*)malloc((GA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
addq $0x3e8, %rdi # imm = 0x3E8
leaq 0x7bac4(%rip), %r15 # 0xdc8b8
movq (%r15), %rbx
imulq $0x368, %rdi, %r13 # imm = 0x368
movq %rdx, 0x2a8(%rbx,%r13)
movq %rdx, 0x8(%rsp)
leaq (,%rdx,8), %rdi
callq 0... | /GlobalArrays[P]ga/global/src/base.c |
pnga_set_memory_dev | void pnga_set_memory_dev(Integer g_a, char *device) {
Integer ga_handle = g_a + GA_OFFSET;
int len = strlen(device);
int i, ilen;
if (len>FNAM) {
pnga_error("Illegal memory device name specified. Device name exceeds length: ",
FNAM);
}
/* convert device name to lower case */
for (i=0; i<len; i... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x30f0
movq %rax, %r15
cmpl $0x20, %r15d
jl 0x63185
leaq 0x56bb9(%rip), %rdi # 0xb9d34
movl $0x1f, %esi
callq 0x18d1b
testl %r15d, %r15d
jle 0x631b2
callq 0x3080
movl %r15d, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xo... | /GlobalArrays[P]ga/global/src/base.c |
pnga_create_irreg_config | logical pnga_create_irreg_config(
Integer type, /* MA type */
Integer ndim, /* number of dimensions */
Integer dims[], /* array of dimensions */
char *array_name, /* array name */
Integer map[], /* decomposition map array */
Integer nblock[], /* number of b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x78(%rsp), %r10
movq 0x70(%rsp), %rax
testq %rsi, %rsi
jle 0x649ee
leaq (,%r13,8), %rdx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3170
movq... | /GlobalArrays[P]ga/global/src/base.c |
pnga_lock | void pnga_lock(Integer mutex)
{
int m,p;
if(GAnproc == 1) return;
if(num_mutexes< mutex)pnga_error("invalid mutex",mutex);
p = num_mutexes/chunk_mutex -1;
m = num_mutexes%chunk_mutex;
ARMCI_Lock(m,p);
} | leaq 0x7431f(%rip), %rax # 0xdc998
cmpq $0x1, (%rax)
jne 0x68680
retq
pushq %rax
movq %rdi, %rsi
movl 0x7434e(%rip), %eax # 0xdc9d8
cmpq %rdi, %rax
jge 0x6869b
leaq 0x51982(%rip), %rdi # 0xba018
callq 0x18d1b
movl 0x74337(%rip), %eax # 0xdc9d8
cltd
idivl 0x74334(%rip) # 0xdc9dc
movl %edx, %edi... | /GlobalArrays[P]ga/global/src/base.c |
pnga_destroy_mutexes | logical pnga_destroy_mutexes()
{
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
if(num_mutexes<1) pnga_error("mutexes destroyed",0);
num_mutexes= 0;
if(GAnproc == 1){
return TRUE;
}
if(ARMCI_Destroy_mutexes()){
return FALSE;
}
return TRUE;
} | pushq %rax
leaq 0x6ea64(%rip), %rax # 0xd7160
movl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x6ea5a(%rip), %rax # 0xd7164
movl %ecx, (%rax)
cmpl $0x0, 0x742c5(%rip) # 0xdc9d8
jg 0x68723
leaq 0x5190a(%rip), %rdi # 0xba026
xorl %esi, %esi
callq 0x18d1b
movl $0x0, 0x742ab(%rip) # 0xdc9d8
leaq 0x74264(%rip), %... | /GlobalArrays[P]ga/global/src/base.c |
pnga_scatter_acc2d | void pnga_scatter_acc2d(g_a, v, i, j, nv, alpha)
Integer g_a, nv, *i, *j;
void *v, *alpha;
{
register Integer k;
Integer item_size;
Integer first, nelem, proc, type=GA[GA_OFFSET + g_a].type;
Integer *int_ptr;
Integer subscrpt[2];
if (nv < 1) return;
ga_check_handleM(g_a, "ga_scatter_acc");
GAstat.n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, 0x38(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %r8, 0x8(%rsp)
testq %r8, %r8
jle 0x6f97d
movq %rdx, %r15
movq %rdi, %r13
leaq 0x6d188(%rip), %r14 # 0xdc8b8
movq (%r14), %rax
leaq 0x3e8... | /GlobalArrays[P]ga/global/src/onesided.c |
gai_gatscat_new | void gai_gatscat_new(int op, Integer g_a, void* v, void *subscript,
Integer c_flag, Integer nv, double *locbytes,
double* totbytes, void *alpha)
{
Integer handle=g_a+GA_OFFSET;
int ndim, i, j, k, type, item_size;
Integer idx, p_handle, num_rstrctd;
Integer *pro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x388, %rsp # imm = 0x388
movq %r9, %r13
movq %r8, %r14
movq %rcx, 0x80(%rsp)
movq %rdx, 0x158(%rsp)
movq %rsi, %r15
movl %edi, 0x5c(%rsp)
leaq 0x3e8(%rsi), %rbx
xorl %eax, %eax
callq 0x68196
movq %rax, %rdi
leaq 0x68ffb(%rip), %rdx ... | /GlobalArrays[P]ga/global/src/onesided.c |
pnga_scatter | void pnga_scatter(Integer g_a, void* v, void *subscript, Integer c_flag, Integer nv)
{
if (nv < 1) return;
ga_check_handleM(g_a, "nga_scatter");
GAstat.numsca++;
#ifdef USE_GATSCAT_NEW
gai_gatscat_new(SCATTER,g_a,v,subscript,c_flag,nv,&GAbytes.scatot,&GAbytes.scaloc, NULL);
#else
gai_gatscat(SCATTER,g_a,... | testq %r8, %r8
jle 0x74b23
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x3e8(%rdi), %rbp
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x74a75
leaq 0x626fb(%rip), %rax ... | /GlobalArrays[P]ga/global/src/onesided.c |
pnga_scatter_acc | void pnga_scatter_acc(Integer g_a, void* v, void *subscript, Integer c_flag,
Integer nv, void *alpha)
{
if (nv < 1) return;
ga_check_handleM(g_a, "nga_scatter_acc");
GAstat.numsca++;
#ifdef USE_GATSCAT_NEW
gai_gatscat_new(SCATTER_ACC, g_a, v, subscript, c_flag, nv, &GAbytes.scatot,
... | testq %r8, %r8
jle 0x74c44
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r11
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x3e8(%rdi), %rbx
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x74b6f
leaq 0x62601... | /GlobalArrays[P]ga/global/src/onesided.c |
pnga_gather2d | void pnga_gather2d(Integer g_a, void *v, Integer *i, Integer *j,
Integer nv)
{
Integer k, kk, proc, item_size;
Integer *aproc, naproc; /* active processes and numbers */
Integer *map; /* map the active processes to allocated space */
char *buf1, *buf2;
Integer hand... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rcx, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
testq %r8, %r8
jle 0x75fa3
movq %r8, %rbp
movq %rdi, %r12
movq %rsi, 0x170(%rsp)
leaq 0x3e8(%rdi), %rbx
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x74c96
leaq 0x6... | /GlobalArrays[P]ga/global/src/onesided.c |
pnga_access_ghost_ptr | void pnga_access_ghost_ptr(Integer g_a, Integer dims[],
void* ptr, Integer ld[])
{
char *lptr;
Integer handle = GA_OFFSET + g_a;
Integer i, lo[MAXDIM], hi[MAXDIM];
Integer ndim = GA[handle].ndim;
Integer me = pnga_nodeid();
pnga_distribution(g_a, me, lo, hi);
for (i=0; i < ndim; i++) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, %r13
movq %rdx, 0x58(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3e8(%rdi), %rax
leaq 0x64a03(%rip), %r15 # 0xdc8b8
movq (%r15), %rcx
imulq $0x368, %rax, %rax # imm = 0x368
movq %rax, 0x28(%... | /GlobalArrays[P]ga/global/src/ghosts.c |
pnga_access_ghost_element | void pnga_access_ghost_element(Integer g_a, AccessIndex* index,
Integer subscript[], Integer ld[])
{
char *ptr=NULL;
Integer handle = GA_OFFSET + g_a;
Integer i=0;
Integer tmp_sub[MAXDIM];
unsigned long elemsize=0;
unsigned long lref=0, lptr=0;
Integer me = pnga_nodeid();
/* Indices co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, 0x18(%rsp)
movq %rdi, (%rsp)
leaq 0x3e8(%rdi), %rbx
xorl %eax, %eax
callq 0x68196
movq %rax, %r10
leaq 0x64462(%rip), %rax # 0xdc8b8
movq (%rax), %r15
movq %rbx, 0x... | /GlobalArrays[P]ga/global/src/ghosts.c |
pnga_update3_ghosts | logical pnga_update3_ghosts(Integer g_a)
{
Integer idx, i, np, handle=GA_OFFSET + g_a, proc_rem;
Integer size, ndim, nwidth, increment[MAXDIM];
Integer width[MAXDIM];
Integer dims[MAXDIM];
Integer lo_loc[MAXDIM], hi_loc[MAXDIM];
Integer plo_loc[MAXDIM]/*, phi_loc[MAXDIM]*/;
Integer tlo_rem[MAXDIM], thi_re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5f8, %rsp # imm = 0x5F8
movq %rdi, %r15
xorl %eax, %eax
callq 0x68196
movq %rax, %rbx
movq %r15, %rdi
callq 0x64ec9
movl $0x1, %ecx
testq %rax, %rax
je 0x7dbfc
leaq 0x3e8(%r15), %rax
leaq 0x606c3(%rip), %rcx # 0xdc8b8
movq (%rcx), ... | /GlobalArrays[P]ga/global/src/ghosts.c |
NGA_Create_config | int NGA_Create_config(int type, int ndim, int dims[], char *name, int chunk[],
int p_handle)
{
Integer *ptr, g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
if(!chunk)ptr=(Integer*)0;
el... | pushq %rbx
subq $0x90, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8d50b
movl %esi, %r10d
testl %esi, %esi
jle 0x8d4b9
movq %r10, %rax
movslq (%rdx), %r11
movq %r11, 0x48(%rsp,%rax,8)
addq $0x4, %rdx
decq %rax
jne 0x8d4a8
xorl %ebx, %ebx
testq %r8, %r8
je 0x8d4e0
leaq 0x10(%rsp), %rax
testl %esi, %esi
jle 0x8d4e2
decq %r... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_irreg | int NGA_Create_irreg(int type,int ndim,int dims[],char *name,int block[],int map[])
{
Integer g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(block,_ga_work, ndim);
_ga_map_cap... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8d651
movq %rcx, %r14
movl %esi, %ebp
movl %edi, %r15d
movl %esi, %eax
testl %esi, %esi
jle 0x8d5db
movq %rax, %rcx
movslq (%rdx), %rsi
movq %rsi, 0x48(%rsp,%rcx,8)
addq $0x4, %rdx
decq %rcx
jne 0x8d5... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_irreg64 | int NGA_Create_irreg64(int type,int ndim,int64_t dims[],char *name,int64_t block[],int64_t map[])
{
Integer g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(block,_ga_work, ndim);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8d79f
movq %rcx, %r14
movl %esi, %ebp
movl %edi, %r15d
movl %esi, %eax
testl %esi, %esi
jle 0x8d729
movq %rax, %rcx
movq (%rdx), %rsi
movq %rsi, 0x48(%rsp,%rcx,8)
addq $0x8, %rdx
decq %rcx
jne 0x8d718... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_ghosts_irreg_config | int NGA_Create_ghosts_irreg_config(int type, int ndim, int dims[], int width[], char *name, int block[], int map[], int p_handle)
{
Integer g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer _ga_width[MAXDIM];
Integer *_ga_map_capi;
if(ndim>MAXDIM)return 0;
COP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8dcac
movq %r8, %r14
movl %esi, %ebp
movl %edi, %r15d
movl %esi, %eax
testl %esi, %esi
jle 0x8dc00
movq %rax, %rsi
movslq (%rdx), %rdi
movq %rdi, 0x88(%rsp,%rsi,8)
addq $0x4, %rdx
decq %rsi
jne 0x8dbe... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_ghosts64 | int NGA_Create_ghosts64(int type, int ndim, int64_t dims[], int64_t width[], char *name,
int64_t chunk[])
{
Integer *ptr, g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer _ga_width[MAXDIM];
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(w... | pushq %rbx
subq $0xd0, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8df0c
movl %esi, %r10d
testl %esi, %esi
jle 0x8de9d
movq %r10, %rax
movq (%rdx), %r11
movq %r11, 0x88(%rsp,%rax,8)
addq $0x8, %rdx
decq %rax
jne 0x8de89
testl %esi, %esi
jle 0x8deb5
movq %r10, %rax
movq (%rcx), %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x8, ... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_ghosts_config64 | int NGA_Create_ghosts_config64(int type, int ndim,int64_t dims[], int64_t width[], char *name,
int64_t chunk[], int p_handle)
{
Integer *ptr, g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer _ga_width[MAXDIM];
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims,... | pushq %rbx
subq $0xd0, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8e07e
movl %esi, %r10d
testl %esi, %esi
jle 0x8e001
movq %r10, %rax
movq (%rdx), %r11
movq %r11, 0x88(%rsp,%rax,8)
addq $0x8, %rdx
decq %rax
jne 0x8dfed
testl %esi, %esi
jle 0x8e019
movq %r10, %rax
movq (%rcx), %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x8, ... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Set_chunk64 | void GA_Set_chunk64(int g_a, int64_t chunk[])
{
Integer aa, *ptr, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
if(!chunk)ptr=(Integer*)0;
else {
COPYC2F(chunk,_ga_work, ndim);
ptr = _ga_work;
}
wnga_set_chunk(aa, ptr);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %r14, %r14
je 0x8e1dd
movq %rsp, %rsi
testq %rax, %rax
jle 0x8e1df
decq %rax
movq (%r14), %rcx
movq %rcx, (%rsp,%rax,8)
addq $0x8, %r14
addq $-0x1, %rax
jb 0x8e1ca
jmp 0x8e1df
xorl %esi, %esi
movq %rbx, %rdi
cal... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_block_cyclic | void NGA_Set_block_cyclic(int g_a, int dims[])
{
Integer aa, ndim;
Integer _ga_dims[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(dims,_ga_dims, ndim);
wnga_set_block_cyclic(aa, _ga_dims);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %rax, %rax
jle 0x8e322
movslq (%r14), %rcx
movq %rcx, -0x8(%rsp,%rax,8)
addq $0x4, %r14
decq %rax
jne 0x8e311
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x606a2
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_restricted | void NGA_Set_restricted(int g_a, int list[], int size)
{
Integer aa;
Integer asize = (Integer)size;
int i;
Integer *_ga_map_capi;
aa = (Integer)g_a;
_ga_map_capi = (Integer*)malloc(size * sizeof(Integer));
for (i=0; i<size; i++)
_ga_map_capi[i] = (Integer)list[i];
wnga_set_restric... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movl %edi, %ebp
movslq %edx, %rbx
leaq (,%rbx,8), %rdi
callq 0x33b0
movq %rax, %r14
testl %ebx, %ebx
jle 0x8e447
movl %r12d, %eax
xorl %ecx, %ecx
movslq (%r15,%rcx,4), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x8e... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Get_proc_index | void NGA_Get_proc_index(int g_a, int iproc, int index[])
{
Integer aa, proc, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
proc = (Integer)iproc;
ndim = wnga_get_dimension(aa);
wnga_get_proc_index(aa, proc, _ga_work);
COPYF2C(_ga_work,index, ndim);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movslq %edi, %r12
movslq %esi, %r13
movq %r12, %rdi
callq 0x60687
movq %rax, %r14
movq %rsp, %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6901f
testq %r14, %r14
jle 0x8e55f
movl (%r15), %eax
movl %eax, -0x4(%rbx,%r14... | /GlobalArrays[P]ga/global/src/capi.c |
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.