name string | code string | asm string | file string |
|---|---|---|---|
void fmt::v9::detail::parse_format_string<false, char, void fmt::v9::detail::vformat_to<char>(fmt::v9::detail::buffer<char>&, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<std::conditional<std::is_same<fmt::v9::type_identity<char>::type, char>::value, fmt::v9::appender, std:... | FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
if (from == to) return;
for (;;) {
const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
return handler_.on_text(from, to);
++p;
if (p == to || *p != '}')
return handler_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdx, %rsi
je 0x3d755
movq %rdx, %rbx
movq %rsi, %r15
subq %rsi, %rdx
js 0x3d724
movq %rdi, %r14
movq %r15, %rdi
movl $0x7d, %esi
callq 0x2b3f0
testq %rax, %rax
je 0x3d73c
movq %rax, %r12
leaq 0x1(%rax), %rdx
cmpq %rbx, %rdx
je 0x3d761
cmpb $0x7d, (%rdx)
jne 0... | /rezalas[P]riftshadow/code/include/spdlog/fmt/bundled/core.h |
spdlog::details::elapsed_formatter<spdlog::details::scoped_padder, std::chrono::duration<long, std::ratio<1l, 1000l>>>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const {
custom_flags cloned_custom_formatters;
for (auto &it : custom_handlers_) {
cloned_custom_formatters[it.first] = it.second->clone();
}
auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x18(%rsi), %rsi
movq %rsi, %rdx
subq 0x18(%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
cmovgq %rdx, %rax
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
mulq %rdx
movq %rdx, %r15
shrq $0x12, %r15
movq %rsi, 0x18(%rdi)
movq %r15, %rax
orq $0x1, %rax
bs... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::details::elapsed_formatter<spdlog::details::scoped_padder, std::chrono::duration<long, std::ratio<1l, 1l>>>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const {
custom_flags cloned_custom_formatters;
for (auto &it : custom_handlers_) {
cloned_custom_formatters[it.first] = it.second->clone();
}
auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x18(%rsi), %rsi
movq %rsi, %rdx
subq 0x18(%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
cmovgq %rdx, %rax
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
mulq %rdx
movq %rdx, %r15
shrq $0x1a, %r15
movq %rsi, 0x18(%rdi)
movq %r15, %rax
orq $0x1, %rax
bs... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::details::Y_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {
const size_t field_size = 4;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(tm_time.tm_year + 1900, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl 0x14(%rdx), %r15d
leal 0x76c(%r15), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movq %rsp, %r14
movq %r14, %rdi
movl $0x15, %edx
callq 0x354f6
cmpl $0xfffff893, %r15d # imm = 0xFFFFF893
jg 0x48966
movb $0x2d, -0x1(%rax)
decq %rax
movq %rax... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::details::m_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mon + 1, dest);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0x10(%rdx), %eax
incl %eax
cmpl $0x63, %eax
ja 0x48d13
movzbl %al, %ebp
imull $0xcd, %ebp, %r14d
shrl $0xb, %r14d
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
orb $0x30, %r14b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::details::f_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {
auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
const size_t field_size = 6;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad6(static_cast<size_t>(micros.cou... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rsi
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %rsi, %rax
imulq %rdx
movq %rdx, %rdi
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rdx
movq %rdi, %rax
shrq $0x3f, %rax
sarq $0x1a, ... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::details::z_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override {
const size_t field_size = 6;
ScopedPadder p(field_size, padinfo_, dest);
auto total_minutes = get_cached_offset(msg, tm_time);
bool is_negative = total_minutes < 0;
if (is_negative) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq 0x18(%rsi), %rsi
movq %rsi, %rax
subq 0x18(%rdi), %rax
movabsq $0x2540be3ff, %rcx # imm = 0x2540BE3FF
cmpq %rcx, %rax
jle 0x49d19
movq 0x28(%rdx), %rcx
movabsq $-0x7777777777777777, %rdx # imm = 0x8888888888888889
movq %rc... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::details::elapsed_formatter<spdlog::details::null_scoped_padder, std::chrono::duration<long, std::ratio<1l, 1000l>>>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const {
custom_flags cloned_custom_formatters;
for (auto &it : custom_handlers_) {
cloned_custom_formatters[it.first] = it.second->clone();
}
auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eo... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rsi
movq %rsi, %rdx
subq 0x18(%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
cmovgq %rdx, %rax
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
mulq %rdx
movq %rcx, %rbx
shrq $0x12, %rdx
movq %rsi, 0x18(%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r... | /rezalas[P]riftshadow/code/include/spdlog/pattern_formatter-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::log(spdlog::details::log_msg const&) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
msg.color_range_start = 0;
msg.color_range_end = 0;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r15
movq %rdi, %r14
movq 0x1c8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2b2a0
testl %eax, %eax
jne 0x4bc4a
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
leaq 0x28(%rsp), %r12
movq $0x0, -0x10(%r12)
leaq 0x12938(%rip), %rax #... | /rezalas[P]riftshadow/code/include/spdlog/sinks/ansicolor_sink-inl.h |
myprintf(char const*, ...) | int myprintf(const char *fmt, ...)
{
int ret;
char buf[1024];
va_list args;
va_start(args, fmt);
ret = vsnprintf(buf, sizeof(buf), fmt, args);
SF_display(buf);
va_end(args);
return ret;
} | pushq %rbp
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x593c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xm... | /zonotopes[P]zono_cpp/statamain.cpp |
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>>::resize(long, long) | EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols)
{
eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime)
&& EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,nbCols==ColsAtCompileTime)
&& EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsA... | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x5f9a
cmpq $0x1, %rdx
jne 0x5f9a
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x5f8e
movq (%r14), %rdi
callq 0x5490
testq %rbx, %rbx
je 0x5f89
movq %rbx, %rax
shrq $0x3d, %rax
jne 0x5f5b
leaq (,%rbx,8), %rdi
callq 0x54f0
testq %rax, %rax
jne 0x5f8b
movl $... | /zonotopes[P]zono_cpp/Eigen/src/Core/PlainObjectBase.h |
readFile(char const*, std::vector<Eigen::Matrix<double, -1, 1, 0, -1, 1>, std::allocator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>>&) | unsigned int readFile(const char *filename, std::vector<Eigen::VectorXd> &star) {
std::ifstream input(filename);
if (!input.is_open()) {
printf("Could not open or find file: %s\n", filename);
return 0;
}
std::string linestr;
unsigned int dim = 0;
// skipping first 3 lines
std::getline(input, linestr);
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rsi, 0x30(%rsp)
movq %rdi, %r14
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5740
leaq 0xf8(%rsp), %rdi
callq 0x50d0
testb %al, %al
je 0x6317
leaq 0x20(%rsp), %rax
movq %ra... | /zonotopes[P]zono_cpp/zonotope.cpp |
aspa_table_update_in_place | enum aspa_status aspa_table_update_in_place(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket,
struct aspa_update_operation *operations, size_t count,
struct aspa_update_operation **failed_operation)
{
// Fail hard in debug builds.
assert(aspa_table);
assert(rtr_socket);
assert(failed_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x6f20
movq %rsi, %rbp
testq %rsi, %rsi
je 0x6f3f
movq %r8, %r15
testq %r8, %r8
je 0x6f5e
movq %rcx, %r13
movq %rdx, %r12
testq %rcx, %rcx
sete %dl
setne %al... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa.c |
aspa_table_update_in_place_undo | enum aspa_status aspa_table_update_in_place_undo(struct aspa_table *aspa_table, struct rtr_socket *rtr_socket,
struct aspa_update_operation *operations, size_t count,
struct aspa_update_operation *failed_operation)
{
// Fail hard in debug builds.
assert(aspa_table);
assert(rtr_socket);
if (!aspa_tabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x38(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
testq %rdi, %rdi
je 0x72ad
movq %rsi, %r12
testq %rsi, %rsi
je 0x72cc
movq %rcx, %rbx
movq %rdx, %r14
testq %rcx, %rcx
sete %dl
setne %al
testq %r14, %r14
sete %cl
orb %cl, %... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa.c |
aspa_table_update_in_place_cleanup | void aspa_table_update_in_place_cleanup(struct aspa_update_operation **operations, size_t count)
{
if (!operations || !*operations)
return;
// If count == 0, this won't be executed
for (size_t i = 0; i < count; i++) {
struct aspa_update_operation *op = &(*operations)[i];
// If it's a remove operation, we ins... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
testq %rdi, %rdi
je 0x737b
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x737b
movq %rsi, %r14
pushq $0x28
popq %r12
movq (%rbx), %r15
subq $0x1, %r14
jb 0x736f
cmpb $0x0, (%r15,%r12)
jne 0x7369
cmpb $0x0, -0x20(%r15,%r12)
jne 0x7369
m... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa.c |
aspa_check_hop | enum aspa_hop_result aspa_check_hop(struct aspa_table *aspa_table, uint32_t customer_asn, uint32_t provider_asn)
{
bool customer_found = false;
for (struct aspa_store_node *node = aspa_table->store; node != NULL; node = node->next) {
struct aspa_record *aspa_record = aspa_array_search(node->aspa_array, customer_as... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
addq $0x78, %r15
xorl %r12d, %r12d
pushq $0x2
popq %rbx
movq (%r15), %r15
testq %r15, %r15
je 0x740f
movq (%r15), %rdi
movl %r14d, %esi
callq 0x7c6d
testq %ra... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa_verification.c |
aspa_verify_as_path | aspa_verification_result aspa_verify_as_path(struct aspa_table *aspa_table, uint32_t as_path[],
size_t len, enum aspa_direction direction)
{
switch (direction) {
case ASPA_UPSTREAM:
return aspa_verify_as_path_upstream(aspa_table, as_path, len);
case ASPA_DOWNSTREAM:
return aspa_verify_as_path_downstream(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
cmpl $0x1, %ecx
je 0x74bd
testl %ecx, %ecx
jne 0x757d
testq %r14, %r14
je 0x74fc
pushq $0x2
popq %rbp
cmpq $0x2, %r12
jb 0x757d
movq %r14, %r... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa_verification.c |
aspa_collapse_as_path | RTRLIB_EXPORT size_t aspa_collapse_as_path(uint32_t as_path[], size_t len)
{
if (len == 0)
return 0;
size_t i = 1;
while (i < len && as_path[i - 1] != as_path[i])
i++;
if (i == len)
return len;
size_t j = i;
i++;
while (true) { // equivalent to while (i < len)
while (i < len && as_path[i - 1] == as... | pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
testq %rsi, %rsi
je 0x7677
pushq $0x1
popq %rax
cmpq %rax, %rsi
je 0x76c3
movl -0x4(%rdi,%rax,4), %ecx
cmpl (%rdi,%rax,4), %ecx
je 0x767b
incq %rax
jmp 0x7664
xorl %esi, %esi
jmp 0x76c3
cmpq %rax, %rsi
je 0x76c3
movq %rax, %rcx
movq %rax, %rdx
incq %rdx
cmpq %rdx, %rsi
m... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa_verification.c |
lrtr_dbg | void lrtr_dbg(const char *frmt, ...)
{
#ifndef NDEBUG
va_list argptr;
struct timeval tv;
struct timezone tz;
va_start(argptr, frmt);
bool fail = true;
if (gettimeofday(&tv, &tz) == 0) {
struct tm tm;
if (localtime_r(&tv.tv_sec, &tm)) {
fprintf(stderr, "(%04d/%02d/%02d %02d:%02d:%02d:%06ld): ", tm.tm_ye... | pushq %r14
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
movq %rsp, %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x7735
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x... | /rtrlib[P]rtrlib/rtrlib/lib/log.c |
aspa_array_create | enum aspa_status aspa_array_create(struct aspa_array **array_ptr)
{
const size_t default_initial_size = 128;
// allocation the chunk of memory of the provider as numbers
struct aspa_record *data_field = lrtr_malloc(sizeof(struct aspa_record) * default_initial_size);
if (!data_field)
return ASPA_ERROR;
struct ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movl $0xc00, %edi # imm = 0xC00
callq 0x5b6d
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x78ce
movq %rax, %r15
pushq $0x18
popq %rdi
callq 0x5b6d
testq %rax, %rax
je 0x78c6
movq $0x80, 0x8(%rax)
andl $0x... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa_array/aspa_array.c |
aspa_array_free | void aspa_array_free(struct aspa_array *array, bool free_provider_arrays)
{
if (!array)
return;
if (array->data) {
if (free_provider_arrays) {
for (size_t i = 0; i < array->size; i++) {
if (array->data[i].provider_asns) {
lrtr_free(array->data[i].provider_asns);
array->data[i].provider_asns = NU... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x7973
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x7952
testb %sil, %sil
je 0x794d
pushq $0x10
popq %r14
xorl %r15d, %r15d
movl (%rbx), %eax
cmpq %rax, %r15
jae 0x794d
movq (%rdi,%r14), %rax
te... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa_array/aspa_array.c |
aspa_array_search | struct aspa_record *aspa_array_search(struct aspa_array *array, uint32_t customer_asn)
{
// if the array is empty we return an error
if (array->size == 0 || array->capacity == 0)
return NULL;
// left and right bound of our search space
register size_t left = 0;
register size_t right = array->size - 1;
// we s... | pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x7cc3
cmpq $0x0, 0x8(%rdi)
je 0x7cc3
decl %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rcx, %rdx
ja 0x7ccd
leaq (%rdx,%rcx), %r9
movq %r9, %r8
shrq %r8
movq 0x10(%rdi), %r10
imulq $0x18, %r8, %r11
cmpl %esi, (%r10,%r11)
je 0x7cc7
jae ... | /rtrlib[P]rtrlib/rtrlib/aspa/aspa_array/aspa_array.c |
test | int test(char *URL)
{
int errors = 0;
(void)URL; /* not used */
#ifdef HAVE_SETLOCALE
/*
* The test makes assumptions about the numeric locale (specifically,
* RADIXCHAR) so set it to a known working (and portable) one.
*/
setlocale(LC_NUMERIC, "C");
#endif
errors += test_weird_arguments();
erro... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, %edi
leaq 0x7e59(%rip), %rsi # 0x9048
callq 0x1080
callq 0x1290
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x1e20
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x2340
addl -0x14(%rbp), %eax
movl %eax... | /nomaster[P]curl/tests/libtest/lib557.c |
test_unsigned_long_formatting | static int test_unsigned_long_formatting(void)
{
int i, j;
int num_ulong_tests;
int failed = 0;
#if (SIZEOF_LONG == 2)
i = 1; ul_test[i].num = 0xFFFFUL; ul_test[i].expected = "65535";
i++; ul_test[i].num = 0xFF00UL; ul_test[i].expected = "65280";
i++; ul_test[i].num = 0x00FFUL; ul_test[i].expected = "255"... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x10(%rbp)
movl $0x1, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2286f(%rip), %rax # 0x26dd0
imulq $0x110, %rcx, %rcx # imm = 0x110
addq %rcx, %rax
movq $-0x1, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x22853(%rip), %rax # 0x26dd0
imulq $0x110, %rcx, %rcx ... | /nomaster[P]curl/tests/libtest/lib557.c |
string_check | static int _string_check(int linenumber, char *buf, const char *buf2)
{
if(strcmp(buf, buf2)) {
/* they shouldn't differ */
printf("sprintf line %d failed:\nwe '%s'\nsystem: '%s'\n",
linenumber, buf, buf2);
return 1;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10b0
cmpl $0x0, %eax
je 0x8a97
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x7cb(%rip), %rdi # 0x9252
movb $0x0, %al
ca... | /nomaster[P]curl/tests/libtest/lib557.c |
bf_hit(char*, char*) | int bf_hit(char *bf, char *line)
{ unsigned i, hashv[NUM_HASHES];
get_hashv(line,strlen(line),hashv);
for(i=0; i<NUM_HASHES; i++)
{ if (BIT_TEST(bf,hashv[i])==0) return 0;
}
return 1;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x163d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
leaq 0x14(%rsp), %rdx
callq 0x19d90
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jae 0x1a06d
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl 0x... | /LAIRLAB[P]vowpal_wabbit/library/recommend.cc |
main | int main(int argc, char *argv[])
{ po::variables_map vm;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("topk", po::value<int>(&topk), "number of items to recommend per user")
("verbose,v", po::value<int>(&verbose), "increase verbosity (can be repeated)... | subq $0x568, %rsp # imm = 0x568
movl $0x0, 0x564(%rsp)
movl %edi, 0x560(%rsp)
movq %rsi, 0x558(%rsp)
leaq 0x4b8(%rsp), %rdi
callq 0x163b0
leaq 0x417(%rsp), %rdi
movq %rdi, 0x210(%rsp)
callq 0x17200
movq 0x210(%rsp), %rdx
leaq 0x2d8fa4(%rip), %rsi # 0x2f3076
leaq 0x418(%rsp), %rdi
callq 0x16d50
jmp 0x1a0e1... | /LAIRLAB[P]vowpal_wabbit/library/recommend.cc |
MURMUR_HASH_3::fmix(unsigned int) | static inline uint32_t fmix(uint32_t h)
{ h ^= h >> 16;
h *= 0x85ebca6b;
h ^= h >> 13;
h *= 0xc2b2ae35;
h ^= h >> 16;
return h;
} | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
imull $0x85ebca6b, -0x4(%rsp), %eax # imm = 0x85EBCA6B
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xd, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
imull $0xc2b2ae35, -0x4(%rsp), %eax # imm = 0xC2B2AE35
m... | /LAIRLAB[P]vowpal_wabbit/explore/hash.h |
really_read(int, void*, unsigned long) | size_t really_read(int sock, void* in, size_t count)
{
char* buf = (char*)in;
size_t done = 0;
int r = 0;
while (done < count)
{
if ((r =
#ifdef _WIN32
recv(sock, buf, (unsigned int)(count - done), 0)
#else
read(sock, buf, (unsigned int)(count - done))
#endif
... | subq $0x348, %rsp # imm = 0x348
movl %edi, 0x33c(%rsp)
movq %rsi, 0x330(%rsp)
movq %rdx, 0x328(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x320(%rsp)
movq $0x0, 0x318(%rsp)
movl $0x0, 0x314(%rsp)
movq 0x318(%rsp), %rax
cmpq 0x328(%rsp), %rax
jae 0x28289
movl 0x33c(%rsp), %edi
movq 0x320(%rsp), %rsi
movq 0x328(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.cc |
send_prediction(int, global_prediction) | void send_prediction(int sock, global_prediction p)
{
if (
#ifdef _WIN32
send(sock, reinterpret_cast<const char*>(&p), sizeof(p), 0)
#else
write(sock, &p, sizeof(p))
#endif
< (int)sizeof(p))
THROWERRNO("send_prediction write(" << sock << ")");
}
void binary_print_result(int f, float res, float ... | subq $0x2f8, %rsp # imm = 0x2F8
movlpd %xmm0, 0x2f0(%rsp)
movl %edi, 0x2ec(%rsp)
movl 0x2ec(%rsp), %edi
leaq 0x2f0(%rsp), %rsi
movl $0x8, %edx
callq 0x16310
cmpq $0x8, %rax
jge 0x284d4
leaq 0x160(%rsp), %rdi
callq 0x16680
leaq 0x170(%rsp), %rdi
leaq 0x2cb3f2(%rip), %rsi # 0x2f3758
callq 0x16920
movq %rax,... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.cc |
vw::predict(std::vector<example*, std::allocator<example*>>&) | void vw::predict(multi_ex& ec)
{
if (!l->is_multiline)
THROW("This reduction does not support multi-line example.");
LEARNER::as_multiline(l)->predict(ec);
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rax), %rax
testb $0x1, 0xe8(%rax)
jne 0x290bf
leaq 0x50(%rsp), %rdi
callq 0x16680
leaq 0x60(%rsp), %rdi
leaq 0x2ca7bd(%rip), %rsi # 0x2f37b8
callq 0x16920
jmp 0x29002
movb ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.cc |
vw::finish_example(example&) | void vw::finish_example(example& ec)
{
if (l->is_multiline)
THROW("This reduction does not support single-line examples.");
LEARNER::as_singleline(l)->finish_example(*this, ec);
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rax), %rax
testb $0x1, 0xe8(%rax)
je 0x2920f
leaq 0x50(%rsp), %rdi
callq 0x16680
leaq 0x60(%rsp), %rdi
leaq 0x2ca637(%rip), %rsi # 0x2f3782
callq 0x16920
jmp 0x29152
movb $... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.cc |
compile_limits(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>>>>, unsigned int*, bool) | void compile_limits(vector<string> limits, uint32_t* dest, bool quiet)
{
for (size_t i = 0; i < limits.size(); i++)
{
string limit = limits[i];
if (isdigit(limit[0]))
{
int n = atoi(limit.c_str());
if (!quiet)
cerr << "limiting to " << n << "features for each namespace." << endl;
... | subq $0xe8, %rsp
movq %rdi, 0x80(%rsp)
movb %dl, %al
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
andb $0x1, %al
movb %al, 0xd7(%rsp)
movq $0x0, 0xc8(%rsp)
movq 0x80(%rsp), %rdi
movq 0xc8(%rsp), %rax
movq %rax, 0x78(%rsp)
callq 0x1f7d0
movq %rax, %rcx
movq 0x78(%rsp), %rax
cmpq %rcx, %rax
jae 0x29a96
movq 0x80(%rsp), %r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.cc |
LEARNER::learner<char, std::vector<example*, std::allocator<example*>>>* LEARNER::as_multiline<char, char>(LEARNER::learner<char, char>*) | multi_learner* as_multiline(learner<T, E>* l)
{
if (l->is_multiline) // Tried to use a singleline reduction as a multiline reduction
return (multi_learner*)(l);
THROW("Tried to use a singleline reduction as a multiline reduction");
} | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rax
testb $0x1, 0xe8(%rax)
je 0x2afc0
movq 0x1d0(%rsp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
retq
leaq 0x48(%rsp), %rdi
callq 0x16680
leaq 0x58(%rsp), %rdi
leaq 0x2c8a00(%rip), %rsi # 0x2f39d6
callq 0x16920
jmp 0x2afdd
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.h |
float* calloc_or_throw<float>(unsigned long) | T* calloc_or_throw(size_t nmemb)
{
if (nmemb == 0)
return nullptr;
void* data = calloc(nmemb, sizeof(T));
if (data == nullptr)
{
const char* msg = "internal error: memory allocation failed!\n";
// use low-level function since we're already out of memory.
fputs(msg, stderr);
THROW(msg);
}
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
cmpq $0x0, 0x1d8(%rsp)
jne 0x2b84b
movq $0x0, 0x1e0(%rsp)
jmp 0x2b981
movq 0x1d8(%rsp), %rdi
movl $0x4, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2b971
leaq 0x2c8024(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0x1c8... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
shared_data* calloc_or_throw<shared_data>(unsigned long) | T* calloc_or_throw(size_t nmemb)
{
if (nmemb == 0)
return nullptr;
void* data = calloc(nmemb, sizeof(T));
if (data == nullptr)
{
const char* msg = "internal error: memory allocation failed!\n";
// use low-level function since we're already out of memory.
fputs(msg, stderr);
THROW(msg);
}
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
cmpq $0x0, 0x1d8(%rsp)
jne 0x2d7fb
movq $0x0, 0x1e0(%rsp)
jmp 0x2d931
movq 0x1d8(%rsp), %rdi
movl $0xe0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2d921
leaq 0x2c6074(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0x1c... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
isbinary(io_buf&) | bool isbinary(io_buf& i)
{
if (i.space.end() == i.head)
if (i.fill(i.files[i.current]) <= 0)
return false;
bool ret = (*i.head == 0);
if (ret)
i.head++;
return ret;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x2acf0
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x60(%rcx), %rax
jne 0x2dbb1
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rsi
callq 0x2e220
movq 0x8(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/io_buf.cc |
io_buf::close_file_or_socket(int) | void io_buf::close_file_or_socket(int f)
{
#ifdef _WIN32
if (io_buf::is_socket(f))
closesocket(f);
else
_close(f);
#else
close(f);
#endif
} | pushq %rax
movl %edi, 0x4(%rsp)
movl 0x4(%rsp), %edi
callq 0x17420
popq %rax
retq
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/io_buf.cc |
v_array<char>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
cmpq 0x1f8(%rsp), %rax
je 0x2e488
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
movq %rcx, 0x1f0(%r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
parse_dictionary_argument(vw&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void parse_dictionary_argument(vw& all, string str)
{
if (str.length() == 0)
return;
// expecting 'namespace:file', for instance 'w:foo.txt'
// in the case of just 'foo.txt' it's applied to the default namespace
char ns = ' ';
const char* s = str.c_str();
if ((str.length() > 2) && (str[1] == ':'))
{
... | subq $0xa58, %rsp # imm = 0xA58
movq %rsi, 0x1e8(%rsp)
movq %rdi, %rax
movq 0x1e8(%rsp), %rdi
movq %rdi, 0x1f0(%rsp)
movq %rax, 0xa50(%rsp)
movq %rdi, 0xa48(%rsp)
callq 0x16ed0
cmpq $0x0, %rax
jne 0x2eb62
jmp 0x300dc
movq 0x1f0(%rsp), %rdi
movb $0x20, 0xa47(%rsp)
callq 0x163a0
movq 0x1f0(%rsp), %rdi
movq %ra... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
VW::are_features_compatible(vw&, vw&) | const char* are_features_compatible(vw& vw1, vw& vw2)
{
if (vw1.p->hasher != vw2.p->hasher)
return "hasher";
if (!equal(vw1.spelling_features, vw1.spelling_features + (sizeof(vw1.spelling_features) / sizeof(bool)),
vw2.spelling_features))
return "spelling_features";
if (!equal(
vw1.a... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x200(%rax), %rax
movq 0x50(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x200(%rcx), %rax
je 0x33ea1
leaq 0x2c0466(%rip), %rax # 0x2f42fd
movq %rax, 0x60(%rsp)
jmp 0x343cf
movq 0x58(%rsp), %rdi
addq $0x1b00, %rdi ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
spoof_hex_encoded_namespaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string spoof_hex_encoded_namespaces(const string& arg)
{
string res;
int pos = 0;
while (pos < (int)arg.size() - 3)
{
if (arg[pos] == '\\' && arg[pos + 1] == 'x')
{
string substr = arg.substr(pos + 2, 2);
char* p;
unsigned char c = (unsigned char)strtoul(substr.c_str(), &p, 16);
... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x16d80
movl $0x0, 0x70(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x78(%rsp), %rdi
callq 0x16670
movq %rax, %rcx
movl 0x1c(%rsp), %eax
subl $0x3, %ecx
cmpl %e... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
parse_example_tweaks(VW::config::options_i&, vw&) | void parse_example_tweaks(options_i& options, vw& all)
{
string named_labels;
string loss_function;
float loss_parameter = 0.0;
size_t early_terminate_passes;
bool test_only = false;
option_group_definition example_options("Example options");
example_options.add(make_option("testonly", test_only).short_n... | subq $0x1558, %rsp # imm = 0x1558
movq %rdi, 0x1550(%rsp)
movq %rsi, 0x1548(%rsp)
leaq 0x1528(%rsp), %rdi
callq 0x16d80
leaq 0x1508(%rsp), %rdi
callq 0x16d80
movl $0x0, 0x1504(%rsp)
movb $0x0, 0x14f7(%rsp)
leaq 0x1497(%rsp), %rdi
movq %rdi, 0x358(%rsp)
callq 0x17200
movq 0x358(%rsp), %rdx
leaq 0x2b9f6b(%rip),... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
parse_output_preds(VW::config::options_i&, vw&) | void parse_output_preds(options_i& options, vw& all)
{
std::string predictions;
std::string raw_predictions;
option_group_definition output_options("Output options");
output_options.add(make_option("predictions", predictions).short_name("p").help("File to output predictions to"))
.add(make_option("raw_pr... | subq $0x478, %rsp # imm = 0x478
movq %rdi, 0x470(%rsp)
movq %rsi, 0x468(%rsp)
leaq 0x448(%rsp), %rdi
callq 0x16d80
leaq 0x428(%rsp), %rdi
callq 0x16d80
leaq 0x3cf(%rsp), %rdi
movq %rdi, 0xe8(%rsp)
callq 0x17200
movq 0xe8(%rsp), %rdx
leaq 0x2b7a54(%rip), %rsi # 0x2f54d9
leaq 0x3d0(%rsp), %rdi
callq 0x16d50... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
load_input_model(vw&, io_buf&) | void load_input_model(vw& all, io_buf& io_temp)
{
// Need to see if we have to load feature mask first or second.
// -i and -mask are from same file, load -i file first so mask can use it
if (!all.feature_mask.empty() && all.initial_regressors.size() > 0 && all.feature_mask == all.initial_regressors[0])
{
/... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
addq $0x2a8, %rdi # imm = 0x2A8
callq 0x17090
testb $0x1, %al
jne 0x3f8f2
movq 0xa0(%rsp), %rdi
addq $0x290, %rdi # imm = 0x290
callq 0x1f7d0
cmpq $0x0, %rax
jbe 0x3f8f2
movq 0xa0(%rsp), %rax
addq $0x2a8, %rax ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
parse_reductions(VW::config::options_i&, vw&) | void parse_reductions(options_i& options, vw& all)
{
// Base algorithms
all.reduction_stack.push(GD::setup);
all.reduction_stack.push(kernel_svm_setup);
all.reduction_stack.push(ftrl_setup);
all.reduction_stack.push(svrg_setup);
all.reduction_stack.push(sender_setup);
all.reduction_stack.push(gd_mf_setup)... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rdi
addq $0x34c0, %rdi # imm = 0x34C0
leaq 0x2c293(%rip), %rax # 0x6bd10
movq %rax, 0x1a0(%rsp)
leaq 0x1a0(%rsp), %rsi
callq 0x49bd0
movq 0x1a8(%rsp), %rdi
addq $0x34c0, %rdi # imm = 0x34C... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
parse_args(VW::config::options_i&, void (*)(void*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), void*) | vw& parse_args(options_i& options, trace_message_t trace_listener, void* trace_context)
{
vw& all = *(new vw());
all.options = &options;
if (trace_listener)
{
all.trace_message.trace_listener = trace_listener;
all.trace_message.trace_context = trace_context;
}
try
{
time(&all.init_time);
... | subq $0x1978, %rsp # imm = 0x1978
movq %rdi, 0x1970(%rsp)
movq %rsi, 0x1968(%rsp)
movq %rdx, 0x1960(%rsp)
movl $0x3658, %edi # imm = 0x3658
callq 0x16940
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x358(%rsp)
callq 0x2a3b0
jmp 0x4035e
movq 0x358(%rsp), %rax
movq %rax, 0x1958(%rsp)
movq 0x1970(%rsp),... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
check_interaction_settings_collision(VW::config::options_i&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool check_interaction_settings_collision(options_i& options, std::string file_options)
{
bool command_line_has_interaction = options.was_supplied("q") || options.was_supplied("quadratic") ||
options.was_supplied("cubic") || options.was_supplied("interactions");
if (!command_line_has_interaction)
return ... | subq $0x138, %rsp # imm = 0x138
movq %rsi, 0x50(%rsp)
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0xf7(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x17200
movq 0x60(%rsp), %rdx
movb $0x0, 0xbe(%rsp)
movb $0x0, 0xbd(%rsp)
movb $0x0, 0x96(%rsp)
movb $0x0, 0x95(%r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_args.cc |
v_hashmap<substring, features*>::get(substring const&, unsigned long) | V& get(const K& key, uint64_t hash)
{
size_t sz = base_size();
size_t first_position = hash % sz;
last_position = first_position;
while (true)
{ // if there's nothing there, obviously we don't contain it
if (!dat[last_position].occupied)
return default_value;
// there's somet... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq %rdx, 0x1e8(%rsp)
movq 0x1f8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56b00
movq %rax, 0x1e0(%rsp)
movq 0x1e8(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x1e0(%rsp)
movq 0x10(%rsp), %rax
movq %rdx, 0x1d8(%rsp)
movq 0x1d... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_hashmap.h |
LEARNER::learner<char, char>* ExpReplay::expreplay_setup<(char)98, simple_label>(VW::config::options_i&, vw&) | LEARNER::base_learner* expreplay_setup(VW::config::options_i& options, vw& all)
{
std::string replay_string = "replay_";
replay_string += er_level;
std::string replay_count_string = replay_string;
replay_count_string += "_count";
auto er = scoped_calloc_or_throw<expreplay>();
VW::config::option_group_defin... | subq $0x388, %rsp # imm = 0x388
movq %rdi, 0x378(%rsp)
movq %rsi, 0x370(%rsp)
leaq 0x34f(%rsp), %rdi
movq %rdi, 0xc8(%rsp)
callq 0x17200
movq 0xc8(%rsp), %rdx
leaq 0x2ac48a(%rip), %rsi # 0x2f60c5
leaq 0x350(%rsp), %rdi
callq 0x16d50
jmp 0x49c4a
leaq 0x34f(%rsp), %rdi
callq 0x169d0
leaq 0x350(%rsp), %rdi
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/expreplay.h |
v_hashmap<substring, features*>::iter(void (*)(substring, features*)) | void iter(void (*func)(K, V))
{ // for (size_t lp=0; lp<base_size(); lp++) {
for (hash_elem* e = dat.begin(); e != dat.end_array; e++)
{ // hash_elem* e = dat.begin()+lp;
if (e->occupied)
{ // printf(" [lp=%d\tocc=%d\thash=%llu]\n", lp, e->occupied, e->hash);
func(e->key, e->val);
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x56bf0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq 0x28(%rcx), %rax
je 0x4cd46
movq 0x20(%rsp), %rax
testb $0x1, (%rax)
je 0x4cd34
movq 0x28(%rsp), ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_hashmap.h |
v_array<float>::clear() | void clear()
{
if (++erase_count & erase_point)
{
resize(_end - _begin);
erase_count = 0;
}
for (T* item = _begin; item != _end; ++item) item->~T();
_end = _begin;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x18(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x18(%rcx)
andq $-0x400, %rax # imm = 0xFC00
cmpq $0x0, %rax
je 0x4daed
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%rdi), %rax
subq %rax, %rsi
sarq $0x2, %rsi
callq 0x4dc00
movq (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
v_array<unsigned long>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
cmpq 0x1f8(%rsp), %rax
je 0x4e26c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sar... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
v_array<std::shared_ptr<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq 0x1f8(%rsp), %rax
je 0x4e5dc
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sar... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
v_hashmap<substring, unsigned long>::double_size() | void double_size()
{ // printf("doubling size!\n");
// remember the old occupants
v_array<hash_elem> tmp = v_array<hash_elem>();
tmp.resize(num_occupants + 10);
for (hash_elem* e = dat.begin(); e != dat.end_array; e++)
if (e->occupied)
tmp.push_back(*e);
// double the size and c... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x164b0
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
addq $0xa, %rsi
leaq 0x40(%rsp), %rdi
callq 0x4f550
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x4f910
movq (%rax), %rax
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_hashmap.h |
sparse_parameters::shallow_copy(sparse_parameters const&) | void shallow_copy(const sparse_parameters& input)
{
// TODO: this is level-1 copy (weight* are stilled shared)
if (!_seeded)
{
for (auto iter = _map.begin(); iter != _map.end(); ++iter) free(iter->second);
}
_map = input._map;
_weight_mask = input._weight_mask;
_stride_shift = input.... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x44(%rax)
jne 0x53e82
movq 0x10(%rsp), %rdi
callq 0x2c480
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2c4d0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2c4b0
testb ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/array_parameters.h |
v_array<unsigned char>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
cmpq 0x1f8(%rsp), %rax
je 0x57228
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
movq %rcx, 0x1f0(%r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
bool* calloc_or_throw<bool>(unsigned long) | T* calloc_or_throw(size_t nmemb)
{
if (nmemb == 0)
return nullptr;
void* data = calloc(nmemb, sizeof(T));
if (data == nullptr)
{
const char* msg = "internal error: memory allocation failed!\n";
// use low-level function since we're already out of memory.
fputs(msg, stderr);
THROW(msg);
}
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
cmpq $0x0, 0x1d8(%rsp)
jne 0x6279b
movq $0x0, 0x1e0(%rsp)
jmp 0x628d1
movq 0x1d8(%rsp), %rdi
movl $0x1, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x628c1
leaq 0x2910d4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0x1c8... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
void ExpReplay::predict_or_learn<true, COST_SENSITIVE::cs_label>(ExpReplay::expreplay&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(expreplay& er, LEARNER::single_learner& base, example& ec)
{ // regardless of what happens, we must predict
base.predict(ec);
// if we're not learning, that's all that has to happen
if (!is_learn || lp.get_weight(&ec.l) == 0.)
return;
for (size_t replay = 1; replay < er.replay_count;... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2aeb0
leaq 0x32f12b(%rip), %rax # 0x392ca8
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rdi
addq $0x6828, %rdi # imm = 0x6828
callq *%rax
cvtss2s... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/expreplay.h |
v_array<substring>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq 0x1f8(%rsp), %rax
je 0x6689c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sar... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
max_elem(float*, int) | float max_elem(float* arr, int length)
{
float max = arr[0];
for (int i = 1; i < length; i++)
if (arr[i] > max)
max = arr[i];
return max;
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x67054
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x10(%rsp), %xmm0
jbe 0x67045
movq -0x8(%rsp),... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/accumulate.cc |
accumulate_weighted_avg(vw&, parameters&) | void accumulate_weighted_avg(vw& all, parameters& weights)
{
if (!all.adaptive)
{
all.trace_message << "Weighted averaging is implemented only for adaptive gradient, use accumulate_avg instead\n";
return;
}
uint32_t length = 1 << all.num_bits; // This is the number of parameters
float* local_weights ... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
testb $0x1, 0x343c(%rax)
jne 0x67129
movq 0x70(%rsp), %rdi
addq $0xe0, %rdi
leaq 0x28f8c9(%rip), %rsi # 0x2f69e8
callq 0x16920
jmp 0x6735a
movq 0x70(%rsp), %rax
movl 0x50(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x64(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/accumulate.cc |
void do_weighting<dense_parameters>(vw&, unsigned long, float*, dense_parameters&) | void do_weighting(vw& all, uint64_t length, float* local_weights, T& weights)
{
for (uint64_t i = 0; i < length; i++)
{
float* weight = &weights[i << weights.stride_shift()];
if (local_weights[i] > 0)
{
float ratio = weight[1] / local_weights[i];
local_weights[i] = weight[0] * ratio;
w... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x677cc
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x53360
movq (%rsp), %rsi
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/accumulate.cc |
GD::setup(VW::config::options_i&, vw&) | base_learner* setup(options_i& options, vw& all)
{
auto g = scoped_calloc_or_throw<gd>();
bool sgd = false;
bool adaptive = false;
bool adax = false;
bool invariant = false;
bool normalized = false;
option_group_definition new_options("Gradient Descent options");
new_options.add(make_option("sgd", sgd... | subq $0xd18, %rsp # imm = 0xD18
movq %rdi, 0xd10(%rsp)
movq %rsi, 0xd08(%rsp)
leaq 0xcf8(%rsp), %rdi
callq 0x714e0
movb $0x0, 0xcf7(%rsp)
movb $0x0, 0xcf6(%rsp)
movb $0x0, 0xcf5(%rsp)
movb $0x0, 0xcf4(%rsp)
movb $0x0, 0xcf3(%rsp)
leaq 0xc97(%rsp), %rdi
movq %rdi, 0x268(%rsp)
callq 0x17200
movq 0x268(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
GD::audit_interaction(GD::audit_results&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*) | inline void audit_interaction(audit_results& dat, const audit_strings* f)
{
if (f == nullptr)
{
if (!dat.ns_pre.empty())
{
dat.ns_pre.pop_back();
}
return;
}
string ns_pre;
if (!dat.ns_pre.empty())
ns_pre += '*';
if (f->first != "" && ((f->first) != " "))
{
ns_pre.append(f... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x6e2fb
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
callq 0x1f070
testb $0x1, %al
jne 0x6e2f6
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
callq 0x72dd0
jmp 0x6e418
leaq 0x18(%rsp), %rdi
callq 0x16d80
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
call... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void INTERACTIONS::generate_interactions<GD::audit_results, unsigned long const, &GD::audit_feature(GD::audit_results&, float, unsigned long), true, &GD::audit_interaction(GD::audit_results&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::... | inline void generate_interactions(vw& all, example_predict& ec, R& dat)
{
if (all.weights.sparse)
generate_interactions<R, S, T, audit, audit_func, sparse_parameters>(
all.interactions, all.permutations, ec, dat, all.weights.sparse_weights);
else
generate_interactions<R, S, T, audit, audit_func, den... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0x6ec0c
movq 0x10(%rsp), %rdi
addq $0x368, %rdi # imm = 0x368
movq 0x10(%rsp), %rax
movb 0x360(%rax), %al
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq 0x10(%rsp), %r8
addq $0x3590, %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions.h |
void GD::predict<false, true>(GD::gd&, LEARNER::learner<char, char>&, example&) | void predict(gd& g, base_learner&, example& ec)
{
vw& all = *g.all;
if (l1)
ec.partial_prediction = trunc_predict(all, ec, all.sd->gravity);
else
ec.partial_prediction = inline_predict(all, ec);
ec.partial_prediction *= (float)all.sd->contraction;
ec.pred.scalar = finalize_prediction(all.sd, ec.parti... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x82be0
movq 0x10(%rsp), %rax
movss %xmm0, 0x68a8(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd 0x60(%rax), %xmm0
cvts... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
version_struct::operator>=(version_struct) | bool operator>=(version_struct v)
{
if (major < v.major)
return false;
if (major > v.major)
return true;
if (minor < v.minor)
return false;
if (minor > v.minor)
return true;
if (rev >= v.rev)
return true;
return false;
} | movq %rsi, -0x28(%rsp)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl (%rax), %eax
cmpl (%rsi), %eax
jge 0x74aa6
movb $0x0, -0x1(%rsp)
jmp 0x74b0d
movq -0x28(%rsp), %rcx
movq -0x20(%rsp), %rax
movl (%rax), %eax
cmpl (%rcx), %eax
jle 0x74abd
movb $0x1, -0x1(%rsp)
jmp 0x7... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.h |
void INTERACTIONS::generate_interactions<GD::trunc_data, float&, &GD::vec_add_trunc(GD::trunc_data&, float, float&), false, &void GD::dummy_func<GD::trunc_data>(GD::trunc_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<ch... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<GD::multipredict_info<sparse_parameters>, unsigned long, &void GD::vec_add_trunc_multipredict<sparse_parameters>(GD::multipredict_info<GD::multipredict_info<sparse_parameters>>&, float, unsigned long), false, &void GD::dummy_func<GD::multipredict_info<sparse_parameters>>(GD::mul... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<GD::multipredict_info<sparse_parameters>, unsigned long, &void GD::vec_add_trunc_multipredict<sparse_parameters>(GD::multipredict_info<GD::multipredict_info<sparse_parameters>>&, float, unsigned long), false, &void GD::dummy_func<GD::multipredict_info<sparse_parameters>>(GD::multipredict... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0x8065d
jmp 0x806d7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<float, float const&, &GD::vec_add(float&, float, float const&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*), sp... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0x83f7d
jmp 0x83ff7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<float, float const&, &GD::vec_add(float&, float, float const&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> co... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<GD::multipredict_info<dense_parameters>, unsigned long, &void GD::vec_add_multipredict<dense_parameters>(GD::multipredict_info<GD::multipredict_info<dense_parameters>>&, float, unsigned long)>(vw&, example&, GD::multipredict_info<dense_parameters>&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0x85406
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::vec_add_multipredict<sparse_parameters>(GD::multipredict_info<sparse_parameters>&, float, unsigned long) | inline void vec_add_multipredict(multipredict_info<T>& mp, const float fx, uint64_t fi)
{
if ((-1e-10 < fx) && (fx < 1e-10))
return;
uint64_t mask = mp.weights.mask();
polyprediction* p = mp.pred;
fi &= mask;
uint64_t top = fi + (uint64_t)((mp.count - 1) * mp.step);
uint64_t i = 0;
if (top <= mask)
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movss %xmm0, 0x3c(%rsp)
movq %rsi, 0x30(%rsp)
movss 0x3c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2716d2(%rip), %xmm1 # 0x2f6b68
ucomisd %xmm1, %xmm0
jbe 0x854b9
movss 0x3c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x2716c2(%rip), %xmm0 # 0x2f6b70
ucomisd %xmm1, %xmm0
jbe 0x8... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void INTERACTIONS::generate_interactions<GD::multipredict_info<sparse_parameters>, unsigned long, &void GD::vec_add_multipredict<sparse_parameters>(GD::multipredict_info<GD::multipredict_info<sparse_parameters>>&, float, unsigned long), false, &void GD::dummy_func<GD::multipredict_info<sparse_parameters>>(GD::multipred... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<GD::multipredict_info<dense_parameters>, unsigned long, &void GD::vec_add_multipredict<dense_parameters>(GD::multipredict_info<GD::multipredict_info<dense_parameters>>&, float, unsigned long), false, &void GD::dummy_func<GD::multipredict_info<dense_parameters>>(GD::multipredict_info<dens... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0x88f0d
jmp 0x88f87
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<GD::multipredict_info<dense_parameters>, unsigned long, &void GD::vec_add_multipredict<dense_parameters>(GD::multipredict_info<GD::multipredict_info<dense_parameters>>&, float, unsigned long), false, &void GD::dummy_func<GD::multipredict_info<dense_parameters>>(GD::multipredict_... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::learn<true, true, true, true, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x8a6c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::b... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0x8b50b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&)>(vw&, example&, GD::norm_data&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0x93a46
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<true, false, 1ul, 2ul, 3ul>(float&, float, float&)>(vw&, example&, float&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0x96036
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::pred_per_update_feature<true, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&) | inline void pred_per_update_feature(norm_data& nd, float x, float& fw)
{
if (feature_mask_off || fw != 0.)
{
weight* w = &fw;
float x2 = x * x;
if (x2 < x2_min)
{
x = (x > 0) ? x_min : -x_min;
x2 = x2_min;
}
if (x2 > x2_max)
THROW("your features have too much magnitude");
... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movss %xmm0, 0x1ec(%rsp)
movq %rsi, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x98750
jp 0x98750
jmp 0x98a70
movq 0x1e0(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movss 0x1ec(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&)>(vw&, example&, GD::norm_data&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0x98b16
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::b... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0x98e5b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::ba... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0x99e9d
jmp 0x99f17
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::ba... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0x9aefd
jmp 0x9af77
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::get_pred_per_update<true, false, false, 1ul, 2ul, 3ul, true>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x3548... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, true, true, false, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9c450
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9c129
jp 0x9c129
jmp 0x9c13e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, true, true, true, 1ul, 2ul, 3ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, true, false, false, 1ul, 2ul, 3ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
unsigned long GD::set_learn<true, true, true, false, 1ul, 0ul, 2ul, 3ul>(vw&, GD::gd&) | uint64_t set_learn(vw& all, gd& g)
{
all.normalized_idx = normalized;
if (g.adax)
{
g.learn = learn<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.update = update<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.sensitiv... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, 0x3470(%rax)
movq -0x18(%rsp), %rax
testb $0x1, 0x5a(%rax)
je 0x9eb70
movq -0x18(%rsp), %rax
leaq 0x84ff(%rip), %rcx # 0xa7040
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x853f(%rip), %rcx # 0xa7090
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, true, true, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9ee50
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9ec39
jp 0x9ec39
jmp 0x9ec4e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, true, true, false, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa6a40
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9ed89
jp 0x9ed89
jmp 0x9ed9e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11:... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0x9f79b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::ba... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xa09ad
jmp 0xa0a27
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &void GD::update_feature<true, true, 1ul, 0ul, 2ul>(float&, float, float&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 1ul, 0ul, 2ul, true>(GD::norm_data&, float, float&)>(vw&, example&, GD::norm_data&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0xa4576
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::learn<true, true, true, false, false, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xa71e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::_... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
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.