name string | code string | asm string | file string |
|---|---|---|---|
void GD::learn<true, false, false, false, true, 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 0xf6e70
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
unsigned long GD::set_learn<false, false, false, true, 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 0xf7640
movq -0x18(%rsp), %rax
leaq 0x10f(%rip), %rcx # 0xf7720
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x14f(%rip), %rcx # 0xf7770
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, false, false, true, true, 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 0xf7770
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, false, false, true, 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 0xf7860
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, false, true, true, 1ul, 0ul, 2ul>(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 |
void GD::learn<false, false, false, false, true, 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 0xf7ed0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, false, false, 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 0xf7fc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, false, false, true, 1ul, 0ul, 2ul>(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 |
void GD::learn<true, true, false, true, true, 0ul, 1ul, 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 0xf8a10
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, true, false, true, true, 0ul, 1ul, 2ul>(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::average_update<false, 0ul, 1ul>(float, float, float) | float average_update(float total_weight, float normalized_sum_norm_x, float neg_norm_power)
{
if (normalized)
{
if (sqrt_rate)
{
float avg_norm = (float)(total_weight / normalized_sum_norm_x);
if (adaptive)
return sqrt(avg_norm);
else
return avg_norm;
}
else
r... | subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
divss 0x14(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
callq 0x16f60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 0ul, 1ul, 2ul, 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 0xf9576
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<false, true, 0ul, 1ul, 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 0xf974b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 0ul, 1ul, 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 |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 0ul, 1ul, 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 |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, true, 0ul, 1ul, 2ul>(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 0xfbbb6
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<false, true, 0ul, 1ul, 2ul>(float&, 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::basic_string<char, std::char_t... | 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 0xfbd2b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &void GD::update_feature<false, true, 0ul, 1ul, 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 |
float GD::get_pred_per_update<false, true, true, 0ul, 1ul, 2ul, 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)
movss 0x3c(%rsp), %xmm0
xorps %xm... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 0ul, 1ul, 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 0xfe656
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<false, true, 0ul, 1ul, 2ul, 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 0xfe99b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 0ul, 1ul, 2ul, 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 0xff9dd
jmp 0xffa57
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<false, true, 0ul, 1ul, 2ul, 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 0x100a3d
jmp 0x100ab7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::compute_update<true, true, false, true, false, 0ul, 1ul, 2ul>(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::get_pred_per_update<false, true, false, 0ul, 1ul, 2ul, false>(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::learn<true, true, false, false, true, 0ul, 1ul, 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 0x1012a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, false, false, true, 0ul, 1ul, 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 0x1014f0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1012d9
jp 0x1012d9
jmp 0x1012ee
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::pred_per_update_feature<false, false, 0ul, 1ul, 2ul, false>(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 0x101aa0
jp 0x101aa0
jmp 0x101d48
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<false, false, 0ul, 1ul, 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::__cxx1... | 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 0x101f5b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 0ul, 1ul, 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 |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 0ul, 1ul, 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::... | 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 0x10316d
jmp 0x1031e7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 0ul, 1ul, 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::... | 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 0x1041cd
jmp 0x104247
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, false, 0ul, 1ul, 2ul>(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 0x1043d6
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<false, false, 0ul, 1ul, 2ul>(float&, 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::basic_string<char, std::char_tr... | 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 0x10471b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<float, float&, &void GD::update_feature<false, false, 0ul, 1ul, 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>, std::... | 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 0x10575d
jmp 0x1057d7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &void GD::update_feature<false, false, 0ul, 1ul, 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<cha... | 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::pred_per_update_feature<false, false, 0ul, 1ul, 2ul, 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 0x106af0
jp 0x106af0
jmp 0x106df8
movq 0x1e0(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movss 0x1ec(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 0ul, 1ul, 2ul, 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::b... | 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 0x10927d
jmp 0x1092f7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::compute_update<false, true, false, true, false, 0ul, 1ul, 2ul>(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 |
void GD::update<false, true, false, false, true, 0ul, 1ul, 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 0x10a510
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10a3b9
jp 0x10a3b9
jmp 0x10a3ce
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, true, false, false, false, 0ul, 1ul, 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 0x10a7d0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10a4a9
jp 0x10a4a9
jmp 0x10a4be
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, false, true, 0ul, 1ul, 2ul>(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 |
void GD::learn<true, false, false, true, false, 0ul, 1ul, 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 0x10adf0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, false, true, false, 0ul, 1ul, 2ul>(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 |
void GD::learn<true, false, false, false, false, 0ul, 1ul, 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 0x10b5b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, false, false, false, false, 0ul, 1ul, 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 0x10b940
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10b5e9
jp 0x10b5e9
jmp 0x10b5fe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, false, true, true, 0ul, 1ul, 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 0x10bf50
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10bdf9
jp 0x10bdf9
jmp 0x10be0e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, false, true, false, 0ul, 1ul, 2ul>(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 |
void GD::learn<false, false, false, false, false, 0ul, 1ul, 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 0x10c610
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, false, false, false, 0ul, 1ul, 2ul>(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 |
void GD::learn<true, true, false, true, true, 0ul, 0ul, 0ul>(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 0x10cf80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void INTERACTIONS::generate_interactions<float, float&, &void GD::update_feature<false, true, 0ul, 0ul, 0ul>(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 INTERACTIONS::inner_kernel<float, float&, &void GD::update_feature<false, true, 0ul, 0ul, 0ul>(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>, std::a... | 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 0x10fa0d
jmp 0x10fa87
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::update<true, true, false, false, true, 0ul, 0ul, 0ul>(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 0x1100f0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10fed9
jp 0x10fed9
jmp 0x10feee
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, false, false, false, 0ul, 0ul, 0ul>(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 0x112a50
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x110029
jp 0x110029
jmp 0x11003e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, true, false, false, true, 0ul, 0ul, 0ul>(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 |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, false, 0ul, 0ul, 0ul>(float&, 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::basic_string<char, std::char_... | 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 0x1106db
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, false, 0ul, 0ul, 0ul>(float&, 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::basic_string<char, std::char_tr... | 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 0x1108ab
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &void GD::update_feature<false, false, 0ul, 0ul, 0ul>(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<cha... | 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<float, float&, &void GD::update_feature<false, false, 0ul, 0ul, 0ul>(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<cha... | 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 |
float GD::compute_update<true, true, false, false, false, 0ul, 0ul, 0ul>(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 |
void GD::learn<false, true, false, true, true, 0ul, 0ul, 0ul>(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 0x112f20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, true, false, true, false, 0ul, 0ul, 0ul>(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 0x113370
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x113049
jp 0x113049
jmp 0x11305e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, true, true, 0ul, 0ul, 0ul>(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 |
void GD::learn<false, true, false, false, false, 0ul, 0ul, 0ul>(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 0x113770
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, false, false, 0ul, 0ul, 0ul>(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, false, false, false, 0ul, 0ul, 0ul, 1ul>(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 0x113f70
movq -0x18(%rsp), %rax
leaq 0x82f(%rip), %rcx # 0x114770
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x86f(%rip), %rcx # 0x1147c0
movq %rcx, 0x40(%rax)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, false, false, false, 0ul, 0ul, 0ul>(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 0x1148b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, false, false, false, 0ul, 0ul, 0ul>(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<false, false, false, true, 0ul, 0ul, 0ul, 1ul>(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 0x114f90
movq -0x18(%rsp), %rax
leaq 0x10f(%rip), %rcx # 0x115070
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x14f(%rip), %rcx # 0x1150c0
movq %rcx, 0x40(%rax)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, false, true, true, 0ul, 0ul, 0ul>(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 0x115250
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1150f9
jp 0x1150f9
jmp 0x11510e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, false, true, false, 0ul, 0ul, 0ul>(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 0x115510
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1151e9
jp 0x1151e9
jmp 0x1151fe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, false, true, false, 0ul, 0ul, 0ul>(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<false, false, false, false, false, 0ul, 0ul, 0ul>(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 |
LEARNER::learner<GD::gd, example>* calloc_or_throw<LEARNER::learner<GD::gd, example>>(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 0x11618b
movq $0x0, 0x1e0(%rsp)
jmp 0x1162c1
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1162b1
leaq 0x1dd6e4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
LEARNER::save(vw&, example*) | void save(vw& all, example* ec)
{
// save state command
string final_regressor_name = all.final_regressor_name;
if ((ec->tag).size() >= 6 && (ec->tag)[4] == '_')
final_regressor_name = string(ec->tag.begin() + 5, (ec->tag).size() - 5);
if (!all.quiet)
all.trace_message << "saving regressor to " << fin... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
addq $0x3570, %rsi # imm = 0x3570
leaq 0xa8(%rsp), %rdi
callq 0x163c0
movq 0xc8(%rsp), %rdi
addq $0x6878, %rdi # imm = 0x6878
callq 0x2ad00
movq %rax, 0x48(%rsp)
jmp 0x1164be
movq 0x48(%rsp), %rax
cmpq $0x6, %rax
jb 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.cc |
LEARNER::generic_driver(std::vector<vw*, std::allocator<vw*>>) | void generic_driver(vector<vw*> alls)
{
generic_driver<vector<vw*>, process_multiple>(**alls.begin(), alls);
// skip first as it already called end_examples()
auto it = alls.begin();
for (it++; it != alls.end(); it++) (*it)->l->end_examples();
} | subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
callq 0x1175e0
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x117610
movq 0x8(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x117620
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1174e0
jmp 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.cc |
LEARNER::generic_driver_onethread(vw&) | void generic_driver_onethread(vw& all)
{
if (all.l->is_multiline)
{
multi_ex ctxt;
auto multi_ex_fptr = [&ctxt](vw& all, v_array<example*> examples) {
all.p->end_parsed_examples += examples.size(); // divergence: lock & signal
for (size_t i = 0; i < examples.size(); ++i) on_new_partial_ex<proce... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq 0x28(%rax), %rax
testb $0x1, 0xe8(%rax)
je 0x116c3a
leaq 0x88(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x117a70
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x80(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.cc |
void LEARNER::multi_ex_generic_driver<&LEARNER::process_multi_ex(vw&, std::vector<example*, std::allocator<example*>>&)>(vw&) | void multi_ex_generic_driver(vw& all)
{
multi_ex ec_seq;
example* ec = nullptr;
while (all.early_terminate == false)
{
ec = VW::get_example(all.p);
on_new_partial_ex<f>(ec, ec_seq, all);
if (ec == nullptr)
break;
}
if (all.early_terminate) // drain any extra examples from parser.
whi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x117a70
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movb 0x3458(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x11790c
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x167ec0
movq %rax, 0x8(%rsp)
jmp 0x1178c6
movq 0x8(%rsp), %rax
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.cc |
void LEARNER::on_new_partial_ex<&LEARNER::process_multi_ex(vw&, std::vector<example*, std::allocator<example*>>&)>(example*, std::vector<example*, std::allocator<example*>>&, vw&) | void on_new_partial_ex(example* ec, multi_ex& ec_seq, vw& all)
{
if (ec != nullptr)
{
if (ec->indices.size() > 1) // 1+ nonconstant feature. (most common case first)
dispatch_multi_ex<f>(all, ec, ec_seq);
else if (ec->end_pass)
dispatch_end_pass(all, *ec);
else if (is_save_cmd(ec))
sa... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1180d6
movq 0x10(%rsp), %rdi
callq 0x117210
cmpq $0x1, %rax
jbe 0x11807f
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1197c0
jmp 0x1180d4
movq 0x10(%rsp), %rax
testb $0x1, 0x68c9(%rax)
je 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.cc |
v_array<example*>::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 0x1184cd
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%rdi), %rax
subq %rax, %rsi
sarq $0x3, %rsi
callq 0x118580
movq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
MWT::save_load(MWT::mwt&, io_buf&, bool, bool) | void save_load(mwt& c, io_buf& model_file, bool read, bool text)
{
if (model_file.files.size() == 0)
return;
stringstream msg;
// total
msg << "total: " << c.total;
bin_text_read_write_fixed_validated(model_file, (char*)&c.total, sizeof(c.total), "", read, msg, text);
// policies
size_t policies_si... | subq $0x2b8, %rsp # imm = 0x2B8
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
andb $0x1, %cl
movb %cl, 0x2a7(%rsp)
andb $0x1, %al
movb %al, 0x2a6(%rsp)
movq 0x2a8(%rsp), %rdi
addq $0x30, %rdi
callq 0x2e240
cmpq $0x0, %rax
jne 0x11a3fa
jmp 0x11a947
leaq 0x118(%rsp), %rdi
callq 0x16... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/mwt.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 |
void MWT::predict_or_learn<true, true, true>(MWT::mwt&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(mwt& c, single_learner& base, example& ec)
{
c.observation = get_observed_cost(ec.l.cb);
if (c.observation != nullptr)
{
c.total++;
// For each nonzero feature in observed namespaces, check it's value.
for (unsigned char ns : ec.indices)
if (c.namespaces[ns])
GD::f... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x110(%rsp), %rdi
addq $0x6828, %rdi # imm = 0x6828
callq 0x119c10
movq %rax, %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x120(%rax)
movq 0x120(%rsp), %rax
cmpq $0x0, 0x120(%rax)
je 0x11c1f7
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/mwt.cc |
void MWT::predict_or_learn<true, false, true>(MWT::mwt&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(mwt& c, single_learner& base, example& ec)
{
c.observation = get_observed_cost(ec.l.cb);
if (c.observation != nullptr)
{
c.total++;
// For each nonzero feature in observed namespaces, check it's value.
for (unsigned char ns : ec.indices)
if (c.namespaces[ns])
GD::f... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x110(%rsp), %rdi
addq $0x6828, %rdi # imm = 0x6828
callq 0x119c10
movq %rax, %rcx
movq 0x120(%rsp), %rax
movq %rcx, 0x120(%rax)
movq 0x120(%rsp), %rax
cmpq $0x0, 0x120(%rax)
je 0x11d017
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/mwt.cc |
void MWT::predict_or_learn<false, false, true>(MWT::mwt&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(mwt& c, single_learner& base, example& ec)
{
c.observation = get_observed_cost(ec.l.cb);
if (c.observation != nullptr)
{
c.total++;
// For each nonzero feature in observed namespaces, check it's value.
for (unsigned char ns : ec.indices)
if (c.namespaces[ns])
GD::f... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
addq $0x6828, %rdi # imm = 0x6828
callq 0x119c10
movq %rax, %rcx
movq 0xb0(%rsp), %rax
movq %rcx, 0x120(%rax)
movq 0xb0(%rsp), %rax
cmpq $0x0, 0x120(%rax)
je 0x11de0d
movq 0xb0(%rsp), %rax
movsd 0x1d5ead(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/mwt.cc |
MWT::mwt* calloc_or_throw<MWT::mwt>(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 0x11e42b
movq $0x0, 0x1e0(%rsp)
jmp 0x11e561
movq 0x1d8(%rsp), %rdi
movl $0x6980, %esi # imm = 0x6980
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x11e551
leaq 0x1d5444(%rip), %rax # 0x2f389f
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
ldamath::vexpdigammify(vw&, float*, float) | void vexpdigammify(vw &all, float *gamma, const float underflow_threshold)
{
float extra_sum = 0.0f;
v4sf sum = v4sfl(0.0f);
float *fp;
const float *fpend = gamma + all.lda;
// Iterate through the initial part of the array that isn't 128-bit SIMD
// aligned.
for (fp = gamma; fp < fpend && !is_aligned16(f... | subq $0xf8, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movss %xmm0, 0x6c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x68(%rsp)
xorps %xmm0, %xmm0
callq 0x123dd0
movaps %xmm0, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rcx
movl 0x3478(%rcx), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x70(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
theta_kl(lda&, v_array<float>&, float*) | float theta_kl(lda &l, v_array<float> &Elogtheta, float *gamma)
{
float gammasum = 0;
Elogtheta.clear();
for (size_t k = 0; k < l.topics; k++)
{
Elogtheta.push_back(l.digamma(gamma[k]));
gammasum += gamma[k];
}
float digammasum = l.digamma(gammasum);
gammasum = l.lgamma(gammasum);
float kl = -(l... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x6c(%rsp)
movq 0x78(%rsp), %rdi
callq 0x4daa0
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x80(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x11f7dd
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
average_diff(vw&, float*, float*) | static inline float average_diff(vw &all, float *oldgamma, float *newgamma)
{
float sum;
float normalizer;
// This warps the normal sense of "inner product", but it accomplishes the same
// thing as the "plain old" for loop. clang does a good job of reducing the
// common subexpressions.
sum = std::inner_p... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movl 0x3478(%rax), %eax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
callq 0x123c80
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
next_pow2(unsigned long) | size_t next_pow2(size_t x)
{
int i = 0;
x = x > 0 ? x - 1 : 0;
while (x > 0)
{
x >>= 1;
i++;
}
return ((size_t)1) << i;
} | movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpq $0x0, -0x8(%rsp)
jbe 0x120255
movq -0x8(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x12025e
xorl %eax, %eax
movq %rax, -0x18(%rsp)
jmp 0x12025e
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
jbe 0x12028a
movq -0x8(%rsp), %rax
shrq %rax
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
return_example(vw&, example&) | void return_example(vw &all, example &ec)
{
all.sd->update(ec.test_only, true, ec.loss, ec.weight, ec.num_features);
for (int f : all.final_prediction_sink) MWT::print_scalars(f, ec.pred.scalars, ec.tag);
if (all.sd->weighted_examples() >= all.sd->dump_interval && !all.quiet)
all.sd->print_update(
al... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rdi
movq 0x88(%rsp), %rax
movb 0x68c8(%rax), %al
movq 0x88(%rsp), %rcx
movss 0x68b0(%rcx), %xmm0
movq 0x88(%rsp), %rcx
movss 0x6870(%rcx), %xmm1
movq 0x88(%rsp), %rcx
movq 0x68a0(%rcx), %rcx
movl $0x1, %edx
andb $0x1, %al
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
learn_batch(lda&) | void learn_batch(lda &l)
{
parameters &weights = l.all->weights;
if (l.sorted_features.empty()) // FAST-PASS for real "true"
{
// This can happen when the socket connection is dropped by the client.
// If l.sorted_features is empty, then l.sorted_features[0] does not
// exist, so we should not try to... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq 0x200(%rsp), %rax
movq 0x188(%rax), %rax
addq $0x3590, %rax # imm = 0x3590
movq %rax, 0x1f8(%rsp)
movq 0x200(%rsp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0x124780
testb $0x1, %al
jne 0x120b39
jmp 0x120d40
movq $0x0, 0x1f0(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
learn_with_metrics(lda&, LEARNER::learner<char, example>&, example&) | void learn_with_metrics(lda &l, LEARNER::single_learner &base, example &ec)
{
if (l.all->passes_complete == 0)
{
// build feature to example map
uint64_t stride_shift = l.all->weights.stride_shift();
uint64_t weight_mask = l.all->weights.mask();
for (features &fs : ec)
{
for (features::it... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq 0x188(%rax), %rax
cmpq $0x0, 0x350(%rax)
jne 0x1220a0
movq 0x90(%rsp), %rax
movq 0x188(%rax), %rdi
addq $0x3590, %rdi # imm = 0x3590
callq 0x4c030
movl %eax, %eax
movq %rax, 0x78(%rsp)
movq 0x90(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
lda_setup(VW::config::options_i&, vw&) | LEARNER::base_learner *lda_setup(options_i &options, vw &all)
{
auto ld = scoped_calloc_or_throw<lda>();
option_group_definition new_options("Latent Dirichlet Allocation");
int math_mode;
new_options.add(make_option("lda", ld->topics).keep().help("Run lda with <int> topics"))
.add(make_option("lda_alpha",... | subq $0xa68, %rsp # imm = 0xA68
movq %rdi, 0xa58(%rsp)
movq %rsi, 0xa50(%rsp)
leaq 0xa40(%rsp), %rdi
callq 0x127a10
leaq 0x9e7(%rsp), %rdi
movq %rdi, 0x1e8(%rsp)
callq 0x17200
movq 0x1e8(%rsp), %rdx
leaq 0x1d4fc9(%rip), %rsi # 0x2f7531
leaq 0x9e8(%rsp), %rdi
callq 0x16d50
jmp 0x122577
leaq 0xa08(%rsp), %r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
ldamath::vfastdigamma(float vector[4]) | inline v4sf vfastdigamma(v4sf x)
{
v4sf twopx = v4sfl(2.0f) + x;
v4sf logterm = vfastlog(twopx);
return (v4sfl(-48.0f) + x * (v4sfl(-157.0f) + x * (v4sfl(-127.0f) - v4sfl(30.0f) * x))) /
(v4sfl(12.0f) * x * (v4sfl(1.0f) + x) * twopx * twopx) +
logterm;
} | subq $0xa8, %rsp
movaps %xmm0, 0x90(%rsp)
movss 0x1cf7f1(%rip), %xmm0 # 0x2f36c8
callq 0x123dd0
movaps 0x90(%rsp), %xmm1
addps %xmm1, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps 0x80(%rsp), %xmm0
callq 0x127fe0
movaps %xmm0, 0x70(%rsp)
movss 0x1d3413(%rip), %xmm0 # 0x2f731c
callq 0x123dd0
movaps %xmm0, 0x30(%rsp)
movaps ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
float ldamath::v4sf_index<1>(float vector[4]) | float v4sf_index(const v4sf x)
{
#if defined(__SSE4_1__)
float ret;
uint32_t val;
val = _mm_extract_ps(x, idx);
// Portably convert uint32_t bit pattern to float. Optimizers will generally
// make this disappear.
memcpy(&ret, &val, sizeof(uint32_t));
return ret;
#else
return _mm_cvtss_f32(_mm_shuffle_p... | movaps %xmm0, -0x28(%rsp)
movaps -0x28(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, -0x18(%rsp)
movss -0x18(%rsp), %xmm0
retq
nopw (%rax,%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
float ldamath::v4sf_index<3>(float vector[4]) | float v4sf_index(const v4sf x)
{
#if defined(__SSE4_1__)
float ret;
uint32_t val;
val = _mm_extract_ps(x, idx);
// Portably convert uint32_t bit pattern to float. Optimizers will generally
// make this disappear.
memcpy(&ret, &val, sizeof(uint32_t));
return ret;
#else
return _mm_cvtss_f32(_mm_shuffle_p... | movaps %xmm0, -0x28(%rsp)
movaps -0x28(%rsp), %xmm0
shufps $0xff, %xmm0, %xmm0 # xmm0 = xmm0[3,3,3,3]
movaps %xmm0, -0x18(%rsp)
movss -0x18(%rsp), %xmm0
retq
nopw (%rax,%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
lda::powf(float, float) | float lda::powf(float x, float p)
{
switch (mmode)
{
case USE_FAST_APPROX:
// std::cerr << "lda::powf FAST_APPROX ";
return ldamath::powf<float, USE_FAST_APPROX>(x, p);
case USE_PRECISE:
// std::cerr << "lda::powf PRECISE ";
return ldamath::powf<float, USE_PRECISE>(x, p);
case US... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x1248df
jmp 0x124897
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x1248c6
jmp 0x1248a2
movl 0xc(%rsp), %eax
subl $0x2, %eax
jne 0x1248f8
jmp 0x1248ad
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
v_array<int>::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 0x124c3d
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%rdi), %rax
subq %rax, %rsi
sarq $0x2, %rsi
callq 0x54e50
movq (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.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.