name string | code string | asm string | file string |
|---|---|---|---|
predict(log_multi&, LEARNER::learner<char, example>&, example&) | void predict(log_multi& b, single_learner& base, example& ec)
{
MULTICLASS::label_t mc = ec.l.multi;
ec.l.simple = {FLT_MAX, 0.f, 0.f};
uint32_t cn = 0;
uint32_t depth = 0;
while (b.nodes[cn].internal)
{
base.predict(ec, b.nodes[cn].base_predictor); // depth
cn = descend(b.nodes[cn], ec.pred.scala... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x6828(%rax), %rax
movq %rax, 0x28(%rsp)
movss 0x1434b4(%rip), %xmm0 # 0x2f36c0
movss %xmm0, 0x1c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x30(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/log_multi.cc |
v_array<node>::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
movl $0x58, %ecx
cqto
idivq %rcx
cmpq 0x1f8(%rsp), %rax
je 0x1b362e
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
s... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
memory_tree_ns::collect_labels_from_leaf(memory_tree_ns::memory_tree&, unsigned int, v_array<unsigned int>&) | void collect_labels_from_leaf(memory_tree& b, const uint32_t cn, v_array<uint32_t>& leaf_labs){
if (b.nodes[cn].internal != -1)
cout<<"something is wrong, it should be a leaf node"<<endl;
leaf_labs.clear();
for (size_t i = 0; i < b.nodes[cn].examples_index.size(); i++){ //scan t... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x1c18b0
cmpl $-0x1, 0x4(%rax)
je 0x1bb13e
movq 0x1d6e25(%rip), %rdi # 0x391f48
leaq 0x1413ad(%rip), %rsi # 0x2fc4d7
callq 0x16920
movq %rax, %rdi
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory_tree.cc |
v_array<memory_tree_ns::node>::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 0x1c2756
movq (%rsp), %rdi
movq 0x8(%rdi), %rax
movq (%rdi), %rcx
subq %rcx, %rax
movl $0x48, %ecx
cqto
idivq %rcx
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
output_and_account_example(vw&, active&, example&) | void output_and_account_example(vw& all, active& a, example& ec)
{
label_data& ld = ec.l.simple;
all.sd->update(ec.test_only, ld.label != FLT_MAX, ec.loss, ec.weight, ec.num_features);
if (ld.label != FLT_MAX && !ec.test_only)
all.sd->weighted_labels += ((double)ld.label) * ec.weight;
all.sd->weighted_unla... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
movq 0x90(%rsp), %rax
movb 0x68c8(%rax), %dl
movq 0x88(%rsp), %rax
movss (%rax), %xmm0
movss 0x12f4de(%rip), ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/active.cc |
active* calloc_or_throw<active>(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 0x1c54db
movq $0x0, 0x1e0(%rsp)
jmp 0x1c5611
movq 0x1d8(%rsp), %rdi
movl $0x10, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1c5601
leaq 0x12e394(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
get_threshold(float, float, float, float) | float get_threshold(float sum_loss, float t, float c0, float alpha)
{
if (t < 3.f)
{
return 1.f;
}
else
{
float avg_loss = sum_loss / t;
float threshold = sqrt(c0 * avg_loss / t) + fmax(2.f * alpha, 4.f) * c0 * log(t) / t;
return threshold;
}
} | subq $0x28, %rsp
movss %xmm0, 0x20(%rsp)
movss %xmm1, 0x1c(%rsp)
movss %xmm2, 0x18(%rsp)
movss %xmm3, 0x14(%rsp)
movss 0x1315ac(%rip), %xmm0 # 0x2f7390
ucomiss 0x1c(%rsp), %xmm0
jbe 0x1c5dfe
movss 0x12d8d1(%rip), %xmm0 # 0x2f36c4
movss %xmm0, 0x24(%rsp)
jmp 0x1c5e8e
movss 0x20(%rsp), %xmm0
divss 0x1c(%rsp), %xmm0
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/active_cover.cc |
LEARNER::learner<active_cover, example>& LEARNER::learner<active_cover, example>::init_learner<LEARNER::learner<char, example>>(active_cover*, LEARNER::learner<char, example>*, void (*)(active_cover&, LEARNER::learner<char, example>&, example&), void (*)(active_cover&, LEARNER::learner<char, example>&, example&), unsig... | static learner<T, E>& init_learner(T* dat, L* base, void (*learn)(T&, L&, E&), void (*predict)(T&, L&, E&), size_t ws,
prediction_type::prediction_type_t pred_type)
{
learner<T, E>& ret = calloc_or_throw<learner<T, E> >();
if (base != nullptr)
{ // a reduction
ret = *(learner<T, E>*)(base);
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
callq 0x1c8510
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1c83e0
movq 0x28(%rsp), %rsi
movq (%rsp), %rdi
movl $0xe9, %edx
callq 0x167a0
movq 0x28(%rsp), %rdi
callq 0x63420... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.h |
void predict_or_learn<true, false>(cs_active&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(cs_active& cs_a, single_learner& base, example& ec)
{
// cerr << "------------- passthrough" << endl;
COST_SENSITIVE::label ld = ec.l.cs;
// cerr << "is_learn=" << is_learn << " ld.costs.size()=" << ld.costs.size() << endl;
if (cs_a.all->sd->queries >= cs_a.min_labels * cs_a.num_classes)
... | subq $0x3f8, %rsp # imm = 0x3F8
movq %rdi, 0x3f0(%rsp)
movq %rsi, 0x3e8(%rsp)
movq %rdx, 0x3e0(%rsp)
movq 0x3e0(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x3c0(%rsp)
movq 0x6830(%rax), %rcx
movq %rcx, 0x3c8(%rsp)
movq 0x6838(%rax), %rcx
movq %rcx, 0x3d0(%rsp)
movq 0x6840(%rax), %rax
movq %rax, 0x3d8(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cs_active.cc |
LEARNER::learner<cs_active, example>& LEARNER::learner<cs_active, example>::init_learner<LEARNER::learner<char, example>>(cs_active*, LEARNER::learner<char, example>*, void (*)(cs_active&, LEARNER::learner<char, example>&, example&), void (*)(cs_active&, LEARNER::learner<char, example>&, example&), unsigned long, predi... | static learner<T, E>& init_learner(T* dat, L* base, void (*learn)(T&, L&, E&), void (*predict)(T&, L&, E&), size_t ws,
prediction_type::prediction_type_t pred_type)
{
learner<T, E>& ret = calloc_or_throw<learner<T, E> >();
if (base != nullptr)
{ // a reduction
ret = *(learner<T, E>*)(base);
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
callq 0x1cfd30
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1cfc00
movq 0x28(%rsp), %rsi
movq (%rsp), %rdi
movl $0xe9, %edx
callq 0x167a0
movq 0x28(%rsp), %rdi
callq 0x63420... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.h |
save_load_flat_example(io_buf&, bool, flat_example*&) | int save_load_flat_example(io_buf& model_file, bool read, flat_example*& fec)
{
size_t brw = 1;
if (read)
{
fec = &calloc_or_throw<flat_example>();
brw = model_file.bin_read_fixed((char*)fec, sizeof(flat_example), "");
if (brw > 0)
{
if (fec->tag_len > 0)
{
fec->tag = calloc_o... | subq $0xb8, %rsp
movb %sil, %al
movq %rdi, 0xa8(%rsp)
andb $0x1, %al
movb %al, 0xa7(%rsp)
movq %rdx, 0x98(%rsp)
movq $0x1, 0x90(%rsp)
testb $0x1, 0xa7(%rsp)
je 0x1d138d
callq 0x15c790
movq %rax, %rcx
movq 0x98(%rsp), %rax
movq %rcx, (%rax)
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), %rax
movq (%rax), %rsi
movl $0xc8, %edx
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/kernel_svm.cc |
predict(svm_params&, LEARNER::learner<char, example>&, example&) | void predict(svm_params& params, single_learner&, example& ec)
{
flat_example* fec = flatten_sort_example(*(params.all), &ec);
if (fec)
{
svm_example* sec = &calloc_or_throw<svm_example>();
sec->init_svm_example(fec);
float score;
predict(params, &sec, &score, 1);
ec.pred.scalar = score;
s... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x15c080
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1d1eaf
callq 0x1d6000
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1d0d50
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/kernel_svm.cc |
void AllReduceSockets::pass_up<char>(char*, unsigned long, unsigned long, unsigned long&) | void pass_up(char* buffer, size_t left_read_pos, size_t right_read_pos, size_t& parent_sent_pos)
{
size_t my_bufsize =
(std::min)(ar_buf_size, (std::min)(left_read_pos, right_read_pos) / sizeof(T) * sizeof(T) - parent_sent_pos);
if (my_bufsize > 0)
{ // going to pass up this chunk of data to the... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x240(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x25220
movq (%rax), %rax
shrq $0x0, %rax
shlq $0x0, %rax
movq 0x2... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/allreduce.h |
LEARNER::learner<svm_params, example>& LEARNER::learner<svm_params, example>::init_learner<LEARNER::learner<char, example>>(svm_params*, LEARNER::learner<char, example>*, void (*)(svm_params&, LEARNER::learner<char, example>&, example&), void (*)(svm_params&, LEARNER::learner<char, example>&, example&), unsigned long, ... | static learner<T, E>& init_learner(T* dat, L* base, void (*learn)(T&, L&, E&), void (*predict)(T&, L&, E&), size_t ws,
prediction_type::prediction_type_t pred_type)
{
learner<T, E>& ret = calloc_or_throw<learner<T, E> >();
if (base != nullptr)
{ // a reduction
ret = *(learner<T, E>*)(base);
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
callq 0x1d9ff0
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1d9ec0
movq 0x28(%rsp), %rsi
movq (%rsp), %rdi
movl $0xe9, %edx
callq 0x167a0
movq 0x28(%rsp), %rdi
callq 0x63420... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.h |
get_best_constant(vw&, float&, float&) | bool get_best_constant(vw& all, float& best_constant, float& best_constant_loss)
{
if (all.sd->first_observed_label == FLT_MAX || // no non-test labels observed or function was never called
(all.loss == nullptr) || (all.sd == nullptr))
return false;
float label1 = all.sd->first_observed_label; // obser... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq 0x108(%rsp), %rax
movq (%rax), %rax
movss 0xd4(%rax), %xmm0
movss 0x1194c6(%rip), %xmm1 # 0x2f36c0
ucomiss %xmm1, %xmm0
jne 0x1da203
jp 0x1da203
jmp 0x1da223
movq 0x108(%rsp), %rax
cmpq $0x0, 0x3548(%ra... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/best_constant.cc |
inner_update_pistol_state_and_predict(update_data&, float, float&) | void inner_update_pistol_state_and_predict(update_data& d, float x, float& wref)
{
float* w = &wref;
float fabs_x = fabs(x);
if (fabs_x > w[W_MX])
w[W_MX] = fabs_x;
float squared_theta = w[W_ZT] * w[W_ZT];
float tmp = 1.f / (d.ftrl_alpha * w[W_MX] * (w[W_G2] + w[W_MX]));
w[W_XT] = sqrt(w[W_G2]) * d.ft... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movss 0x2c(%rsp), %xmm0
callq 0x8ab80
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movq 0x18(%rsp), %rax
ucomiss 0xc(%rax), %xmm0
jbe 0x1dadf0
movss 0x14(%rsp), %xmm0
movq 0x18(%rsp), %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/ftrl.cc |
update_state_and_predict_cb(ftrl&, LEARNER::learner<char, example>&, example&) | void update_state_and_predict_cb(ftrl& b, single_learner&, example& ec)
{
b.data.predict = 0;
b.data.normalized_squared_norm_x = 0;
GD::foreach_feature<update_data, inner_update_cb_state_and_predict>(*b.all, ec, b.data);
b.all->normalized_sum_norm_x += ((double)ec.weight) * b.data.normalized_squared_norm_x;
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rax)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x10, %rdx
callq 0x1dd260
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/ftrl.cc |
void multipredict<false>(ftrl&, LEARNER::learner<char, char>&, example&, unsigned long, unsigned long, polyprediction*, bool) | void multipredict(
ftrl& b, base_learner&, example& ec, size_t count, size_t step, polyprediction* pred, bool finalize_predictions)
{
vw& all = *b.all;
for (size_t c = 0; c < count; c++) pred[c].scalar = ec.l.simple.initial;
if (b.all->weights.sparse)
{
GD::multipredict_info<sparse_parameters> mp = {
... | subq $0xa8, %rsp
movb 0xb0(%rsp), %al
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x88(... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/ftrl.cc |
void GD::foreach_feature<update_data, float&, &inner_update_cb_state_and_predict(update_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::basic_string<char, std::char_traits<ch... | 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 0x1e066b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void GD::foreach_feature<update_data, float&, &inner_update_pistol_state_and_predict(update_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::basic_string<char, std::char_trait... | 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 0x1e2bcb
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<update_data, float&, &inner_update_pistol_state_and_predict(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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 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 0x1e3c0d
jmp 0x1e3c87
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<update_data, float&, &inner_update_pistol_state_and_predict(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_t... | 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<update_data, float&, &inner_update_cb_post(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocato... | 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 0x1eabfd
jmp 0x1eac77
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 SVRG::vec_add<0>(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_traits<char>, std::allocator<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 0x1efe8b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &void SVRG::vec_add<0>(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::allocator<char>>> cons... | 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<SVRG::update, float&, &SVRG::update_inner_feature(SVRG::update&, float, float&), false, &void GD::dummy_func<SVRG::update>(SVRG::update&, 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 0x1f34ad
jmp 0x1f3527
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<float, float&, &SVRG::update_stable_feature(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::allocator<char>>> const*)... | 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 0x1f6aad
jmp 0x1f6b27
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
multiply(features&, features&, interact&) | void multiply(features& f_dest, features& f_src2, interact& in)
{
f_dest.clear();
features& f_src1 = in.feat_store;
vw* all = in.all;
uint64_t weight_mask = all->weights.mask();
uint64_t base_id1 = f_src1.indicies[0] & weight_mask;
uint64_t base_id2 = f_src2.indicies[0] & weight_mask;
f_dest.push_back(f_... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x47d70
movq 0xa0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
callq 0x7... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interact.cc |
void predict_or_learn<false, true>(interact&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(interact& in, LEARNER::single_learner& base, example& ec)
{
features& f1 = ec.feature_space[in.n1];
features& f2 = ec.feature_space[in.n2];
if (!contains_valid_namespaces(*in.all, f1, f2, in))
{
if (is_learn)
base.learn(ec);
else
base.predict(ec);
return;
}
i... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x20, %rax
movq 0x60(%rsp), %rcx
movzbl (%rcx), %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
addq $0x20, %rax
movq 0x60(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
imulq $0x6... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interact.cc |
LEARNER::learner<interact, example>* calloc_or_throw<LEARNER::learner<interact, 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 0x1fb6bb
movq $0x0, 0x1e0(%rsp)
jmp 0x1fb7f1
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1fb7e1
leaq 0xf81b4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
comp_io_buf::close_file() | bool comp_io_buf::close_file()
{
if (gz_files.size() > 0)
{
gzclose(gz_files.back());
gz_files.pop_back();
if (files.size() > 0)
files.pop();
return true;
}
return false;
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
addq $0xa8, %rdi
callq 0x1fbdc0
cmpq $0x0, %rax
jbe 0x1fbd33
movq (%rsp), %rdi
addq $0xa8, %rdi
callq 0x1fbe00
movq (%rax), %rdi
callq 0x170f0
movq (%rsp), %rdi
addq $0xa8, %rdi
callq 0x1fbe40
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x2e240
c... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/comp_io.cc |
INTERACTIONS::expand_interactions(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | std::vector<std::string> expand_interactions(
const vector<string>& vec, const size_t required_length, const string& err_msg)
{
std::vector<std::string> res;
for (string const& i : vec)
{
const size_t len = i.length();
if (required_length > 0 && len != required_length)
// got strict requirement o... | subq $0x418, %rsp # imm = 0x418
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x410(%rsp)
movq %rsi, 0x408(%rsp)
movq %rdx, 0x400(%rsp)
movq %rcx, 0x3f8(%rsp)
movb $0x0, 0x3f7(%rsp)
callq 0x24ba0
movq 0x408(%rsp), %rax
movq %rax, 0x3e8(%rsp)
movq 0x3e8(%rsp), %rdi
callq 0x1f290
movq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions.cc |
INTERACTIONS::eval_count_of_generated_ft(vw&, example&, unsigned long&, float&) | void eval_count_of_generated_ft(vw& all, example& ec, size_t& new_features_cnt, float& new_features_value)
{
new_features_cnt = 0;
new_features_value = 0.;
v_array<float> results = v_init<float>();
if (all.permutations)
{
// just multiply precomputed values for all namespaces
for (std::string& inter... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq %rdx, 0x190(%rsp)
movq %rcx, 0x188(%rsp)
movq 0x190(%rsp), %rax
movq $0x0, (%rax)
movq 0x188(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
leaq 0x168(%rsp), %rdi
callq 0x4d940
movq 0x1a0(%rsp), %rax
testb $0x1, 0x360(%rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions.cc |
audit_regressor(audit_regressor_data&, LEARNER::learner<char, example>&, example&) | void audit_regressor(audit_regressor_data& rd, LEARNER::single_learner& base, example& ec)
{
vw& all = *rd.all;
if (all.lda > 0)
audit_regressor_lda(rd, base, ec);
else
{
rd.cur_class = 0;
uint64_t old_offset = ec.ft_offset;
while (rd.cur_class < rd.total_class_cnt)
{
for (unsigned c... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
cmpl $0x0, 0x3478(%rax)
jbe 0x208013
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x207b00
jmp 0x208353
movq 0x80(%rsp), %rax
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/audit_regressor.cc |
audit_regressor_interaction(audit_regressor_data&, 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_regressor_interaction(audit_regressor_data& dat, const audit_strings* f)
{
// same as audit_interaction in gd.cc
if (f == nullptr)
{
dat.ns_pre->pop_back();
return;
}
string ns_pre;
if (!dat.ns_pre->empty())
ns_pre += '*';
if (f->first != "" && ((f->first) != " "))
{
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x209a49
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x72dd0
jmp 0x209b56
leaq 0x18(%rsp), %rdi
callq 0x16d80
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1f070
testb $0x1, %al
jne 0x209a95
leaq 0x18(%rsp), %rdi
movl $0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/audit_regressor.cc |
void INTERACTIONS::generate_interactions<audit_regressor_data, unsigned long const, &audit_regressor_feature(audit_regressor_data&, float, unsigned long), true, &audit_regressor_interaction(audit_regressor_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::bas... | 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 $0x328, %rsp # imm = 0x328
movb %sil, %al
movq %rdi, 0x320(%rsp)
andb $0x1, %al
movb %al, 0x31f(%rsp)
movq %rdx, 0x310(%rsp)
movq %rcx, 0x308(%rsp)
movq %r8, 0x300(%rsp)
movq 0x310(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2f8(%rsp)
movq 0x310(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2f0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<audit_regressor_data, unsigned long const, &audit_regressor_feature(audit_regressor_data&, float, unsigned long), true, &audit_regressor_interaction(audit_regressor_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string... | 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 $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movss %xmm0, 0x3c(%rsp)
movq %r9, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0x20c9b0
jmp 0x20ca61
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
CB_EXPLORE::print_update_cb_explore(vw&, bool, example&, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&) | void print_update_cb_explore(vw& all, bool is_test, example& ec, stringstream& pred_string)
{
if (all.sd->weighted_examples() >= all.sd->dump_interval && !all.quiet && !all.bfgs)
{
stringstream label_string;
if (is_test)
label_string << " unknown";
else
label_string << ec.l.cb.costs[0].actio... | subq $0x228, %rsp # imm = 0x228
movb %sil, %al
movq %rdi, 0x220(%rsp)
andb $0x1, %al
movb %al, 0x21f(%rsp)
movq %rdx, 0x210(%rsp)
movq %rcx, 0x208(%rsp)
movq 0x220(%rsp), %rax
movq (%rax), %rdi
callq 0x4c940
movq 0x220(%rsp), %rax
movq (%rax), %rax
movss 0x50(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1,... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore.cc |
void CB_EXPLORE::predict_or_learn_bag<true>(CB_EXPLORE::cb_explore&, LEARNER::learner<char, example>&, example&) | void predict_or_learn_bag(cb_explore& data, single_learner& base, example& ec)
{
// Randomize over predictions from a base set of predictors
action_scores probs = ec.pred.a_s;
probs.clear();
for (uint32_t i = 0; i < data.cbcs.num_actions; i++) probs.push_back({i, 0.});
float prob = 1.f / (float)data.bag_size... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x6850(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x6858(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x6860(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x6868(%rax), %rax
movq %rax, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore.cc |
void CB_EXPLORE::predict_or_learn_greedy<true>(CB_EXPLORE::cb_explore&, LEARNER::learner<char, example>&, example&) | void predict_or_learn_greedy(cb_explore& data, single_learner& base, example& ec)
{
// Explore uniform random an epsilon fraction of the time.
// TODO: pointers are copied here. What happens if base.learn/base.predict re-allocs?
// ec.pred.a_s = probs; will restore the than free'd memory
action_scores probs = e... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x6850(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x6858(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x6860(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x6868(%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore.cc |
CB_EXPLORE::cb_explore* calloc_or_throw<CB_EXPLORE::cb_explore>(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 0x21147b
movq $0x0, 0x1e0(%rsp)
jmp 0x2115b1
movq 0x1d8(%rsp), %rdi
movl $0x138, %esi # imm = 0x138
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2115a1
leaq 0xe23f4(%rip), %rax # 0x2f389f
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
void GEN_CS::gen_cs_example_dr<false>(GEN_CS::cb_to_cs&, example&, CB::label&, COST_SENSITIVE::label&) | void gen_cs_example_dr(cb_to_cs& c, example& ec, CB::label& ld, COST_SENSITIVE::label& cs_ld)
{ // this implements the doubly robust method
cs_ld.costs.clear();
c.pred_scores.costs.clear();
if (ld.costs.size() == 0) // a test example
for (uint32_t i = 1; i <= c.num_actions; i++)
{ // Explicit declarati... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x211c50
movq 0x50(%rsp), %rdi
addq $0x10, %rdi
callq 0x211c50
movq 0x40(%rsp), %rdi
callq 0x1172a0
cmpq $0x0, %rax
jne 0x21250f
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq 0x50(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gen_cs_example.h |
void GEN_CS::gen_cs_label<false>(GEN_CS::cb_to_cs&, example&, COST_SENSITIVE::label&, unsigned int) | void gen_cs_label(cb_to_cs& c, example& ec, COST_SENSITIVE::label& cs_ld, uint32_t action)
{
COST_SENSITIVE::wclass wc = {0., action, 0., 0.};
// get cost prediction for this action
wc.x = CB_ALGS::get_cost_pred<is_learn>(c.scorer, c.known_cost, ec, action, c.num_actions);
c.pred_scores.costs.push_back(wc);
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdi... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gen_cs_example.h |
ACTION_SCORE::print_action_score(int, v_array<ACTION_SCORE::action_score>&, v_array<char>&) | void print_action_score(int f, v_array<action_score>& a_s, v_array<char>&)
{
if (f >= 0)
{
std::stringstream ss;
for (size_t i = 0; i < a_s.size(); i++)
{
if (i > 0)
ss << ',';
ss << a_s[i].action << ':' << a_s[i].score;
}
ss << '\n';
ssize_t len = ss.str().size();
s... | subq $0x278, %rsp # imm = 0x278
movl %edi, 0x274(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
cmpl $0x0, 0x274(%rsp)
jl 0x212e8b
leaq 0xd8(%rsp), %rdi
callq 0x16680
movq $0x0, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x268(%rsp), %rdi
callq 0x169380
movq %rax, 0x68(%rsp)
jmp 0x212c4... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/action_score.cc |
cb_explore_adf_setup(VW::config::options_i&, vw&) | base_learner* cb_explore_adf_setup(options_i& options, vw& all)
{
auto data = scoped_calloc_or_throw<cb_explore_adf>();
bool cb_explore_adf_option = false;
bool softmax = false;
bool regcb = false;
std::string type_string = "mtr";
option_group_definition new_options("Contextual Bandit Exploration with Actio... | subq $0x1758, %rsp # imm = 0x1758
movq %rdi, 0x1748(%rsp)
movq %rsi, 0x1740(%rsp)
leaq 0x1730(%rsp), %rdi
callq 0x219a00
movb $0x0, 0x172f(%rsp)
movb $0x0, 0x172e(%rsp)
movb $0x0, 0x172d(%rsp)
leaq 0x1707(%rsp), %rdi
movq %rdi, 0x450(%rsp)
callq 0x17200
movq 0x450(%rsp), %rdx
leaq 0xed40f(%rip), %rsi # 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore_adf.cc |
void CB_EXPLORE_ADF::do_actual_learning<true>(CB_EXPLORE_ADF::cb_explore_adf&, LEARNER::learner<char, std::vector<example*, std::allocator<example*>>>&, std::vector<example*, std::allocator<example*>>&) | void do_actual_learning(cb_explore_adf& data, multi_learner& base, multi_ex& ec_seq)
{
example* label_example = test_adf_sequence(ec_seq);
data.gen_cs.known_cost = CB_ADF::get_observed_cost(ec_seq);
if (label_example == nullptr || !is_learn)
{
if (label_example != nullptr) // extract label
{
dat... | subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, 0x3d0(%rsp)
movq %rsi, 0x3c8(%rsp)
movq %rdx, 0x3c0(%rsp)
movq 0x3c0(%rsp), %rdi
callq 0x212ed0
movq %rax, 0x3b8(%rsp)
movq 0x3c0(%rsp), %rdi
callq 0x2a8fd0
movq %rax, 0x3a8(%rsp)
movlpd %xmm0, 0x3b0(%rsp)
movq 0x3d0(%rsp), %rax
movq 0x3a8(%rsp), %rcx
movq %rcx, 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore_adf.cc |
CB_EXPLORE_ADF::cb_explore_adf* calloc_or_throw<CB_EXPLORE_ADF::cb_explore_adf>(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 0x21cd1b
movq $0x0, 0x1e0(%rsp)
jmp 0x21ce51
movq 0x1d8(%rsp), %rdi
movl $0x250, %esi # imm = 0x250
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x21ce41
leaq 0xd6b54(%rip), %rax # 0x2f389f
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
LEARNER::learner<CB_EXPLORE_ADF::cb_explore_adf, std::vector<example*, std::allocator<example*>>>* calloc_or_throw<LEARNER::learner<CB_EXPLORE_ADF::cb_explore_adf, std::vector<example*, std::allocator<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 0x21d41b
movq $0x0, 0x1e0(%rsp)
jmp 0x21d551
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x21d541
leaq 0xd6454(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
void CB_EXPLORE_ADF::predict_or_learn_regcb<false>(CB_EXPLORE_ADF::cb_explore_adf&, LEARNER::learner<char, std::vector<example*, std::allocator<example*>>>&, std::vector<example*, std::allocator<example*>>&) | void predict_or_learn_regcb(cb_explore_adf& data, multi_learner& base, multi_ex& examples)
{
if (is_learn && test_adf_sequence(examples) != nullptr)
{
for (size_t i = 0; i < examples.size() - 1; ++i)
{
CB::label& ld = examples[i]->l.cb;
if (ld.costs.size() == 1)
ld.costs[0].probability =... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xb0(%rsp), %rax
movq 0x88(%rax), %rdx
xorl %ecx, %ecx
movl %ecx, 0x28(%rsp)
callq 0x1a4c20
movl 0x28(%rsp), %eax
movq 0xa0(%rsp), %rdi
movl %eax, %esi
callq 0x192c60
movq (%rax), %rax
add... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore_adf.cc |
void CB_EXPLORE_ADF::predict_or_learn_regcb<true>(CB_EXPLORE_ADF::cb_explore_adf&, LEARNER::learner<char, std::vector<example*, std::allocator<example*>>>&, std::vector<example*, std::allocator<example*>>&) | void predict_or_learn_regcb(cb_explore_adf& data, multi_learner& base, multi_ex& examples)
{
if (is_learn && test_adf_sequence(examples) != nullptr)
{
for (size_t i = 0; i < examples.size() - 1; ++i)
{
CB::label& ld = examples[i]->l.cb;
if (ld.costs.size() == 1)
ld.costs[0].probability =... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x212ed0
cmpq $0x0, %rax
je 0x2207de
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x117320
movq %rax, %rcx
movq 0x20(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_explore_adf.cc |
v_array<CB::label>::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 0x221c0d
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%rdi), %rax
subq %rax, %rsi
sarq $0x5, %rsi
callq 0x221f60
movq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
v_array<CB::label>::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 $0x5, %rax
cmpq 0x1f8(%rsp), %rax
je 0x2221ac
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sa... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
void GEN_CS::gen_cs_example<false>(GEN_CS::cb_to_cs_adf&, std::vector<example*, std::allocator<example*>>&, COST_SENSITIVE::label&) | void gen_cs_example(cb_to_cs_adf& c, multi_ex& ec_seq, COST_SENSITIVE::label& cs_labels)
{
switch (c.cb_type)
{
case CB_TYPE_IPS:
gen_cs_example_ips(ec_seq, cs_labels);
break;
case CB_TYPE_DR:
gen_cs_example_dr<is_learn>(c, ec_seq, cs_labels);
break;
case CB_TYPE_MTR:
gen_c... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movq 0x1f0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x22241a
jmp 0x2223e6
movq 0x18(%rsp), %rax
subq $0x2, %rax
je 0x222400
jmp 0x2223f3
movq 0x18(%rsp), %rax
subq $0x3, %rax
je... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gen_cs_example.h |
float CB_ALGS::get_cost_pred<true>(LEARNER::learner<char, example>*, CB::cb_class*, example&, unsigned int, unsigned int) | float get_cost_pred(
LEARNER::single_learner* scorer, CB::cb_class* known_cost, example& ec, uint32_t index, uint32_t base)
{
CB::label ld = ec.l.cb;
label_data simple_temp;
simple_temp.initial = 0.;
if (known_cost != nullptr && index == known_cost->action)
simple_temp.label = known_cost->cost;
else
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl %r8d, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x6830(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x6838(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x6840(%rax), %rax
movq %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_algs.h |
finish(OjaNewton&) | void finish(OjaNewton& ON)
{
free(ON.ev);
free(ON.b);
free(ON.D);
free(ON.buffer);
free(ON.weight_buffer);
free(ON.zv);
free(ON.vv);
free(ON.tmp);
for (int i = 1; i <= ON.m; i++)
{
free(ON.A[i]);
free(ON.K[i]);
}
free(ON.A);
free(ON.K);
free(ON.data.Zx);
free(ON.data.AZx);
free... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x16b20
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x16b20
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x16b20
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x16b20
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.cc |
update_Z_and_wbar(update_data&, float, float&) | void update_Z_and_wbar(update_data& data, float x, float& wref)
{
float* w = &wref;
int m = data.ON->m;
if (data.ON->normalize)
x /= sqrt(w[NORM2]);
float s = data.sketch_cnt * x;
for (int i = 1; i <= m; i++)
{
w[i] += data.delta[i] * s / data.ON->D[i];
}
w[0] -= s * data.bdelta;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0xac(%rax)
je 0x22300a
movq 0x18(%rsp), %rax
movl 0x14(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.cc |
save_load(OjaNewton&, io_buf&, bool, bool) | void save_load(OjaNewton& ON, io_buf& model_file, bool read, bool text)
{
vw& all = *ON.all;
if (read)
{
initialize_regressor(all);
ON.initialize_Z(all.weights);
}
if (model_file.files.size() > 0)
{
bool resume = all.save_resume;
stringstream msg;
msg << ":" << resume << "\n";
bin_t... | subq $0x1d8, %rsp # imm = 0x1D8
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
andb $0x1, %cl
movb %cl, 0x1c7(%rsp)
andb $0x1, %al
movb %al, 0x1c6(%rsp)
movq 0x1d0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x1b8(%rsp)
testb $0x1, 0x1c7(%rsp)
je 0x2236b4
movq 0x1b8(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.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 |
OjaNewton::update_eigenvalues() | void update_eigenvalues()
{
for (int i = 1; i <= m; i++)
{
float gamma = fmin(learning_rate_cnt / t, 1.f);
float tmp = data.AZx[i] * data.sketch_cnt;
if (t == 1)
{
ev[i] = gamma * tmp * tmp;
}
else
{
ev[i] = (1 - gamma) * t * ev[i] / (t - 1) + gamma *... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jg 0x22549f
movq 0x8(%rsp), %rax
movss 0xa8(%rax), %xmm0
cvtsi2ssl 0x18(%rax), %xmm1
divss %xmm1, %xmm0
movss 0xce2f9(%rip), %xmm1 # 0x2f36c4
callq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.cc |
OjaNewton::update_K() | void update_K()
{
float tmp = data.norm2_x * data.sketch_cnt * data.sketch_cnt;
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= m; j++)
{
K[i][j] += data.delta[i] * data.Zx[j] * data.sketch_cnt;
K[i][j] += data.delta[j] * data.Zx[i] * data.sketch_cnt;
K[i][j] += dat... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movss 0x80(%rax), %xmm0
mulss 0x7c(%rax), %xmm0
mulss 0x7c(%rax), %xmm0
movss %xmm0, -0xc(%rsp)
movl $0x1, -0x10(%rsp)
movq -0x20(%rsp), %rcx
movl -0x10(%rsp), %eax
cmpl 0x8(%rcx), %eax
jg 0x2256f4
movl $0x1, -0x14(%rsp)
movq -0x20(%rsp), %rcx
movl -0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.cc |
OjaNewton::update_b() | void update_b()
{
for (int j = 1; j <= m; j++)
{
float tmp = 0;
for (int i = j; i <= m; i++)
{
tmp += ev[i] * data.AZx[i] * A[i][j] / (alpha * (alpha + ev[i]));
}
b[j] += tmp * data.g;
}
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x1, -0xc(%rsp)
movq -0x20(%rsp), %rcx
movl -0xc(%rsp), %eax
cmpl 0x8(%rcx), %eax
jg 0x225bca
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rcx
movl -0x14(%rsp), %eax
cmpl 0x8(%rcx), %e... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.cc |
OjaNewton::initialize_Z(parameters&) | void initialize_Z(parameters& weights)
{
uint32_t length = 1 << all->num_bits;
if (normalize) // initialize normalization part
{
for (uint32_t i = 0; i < length; i++) (&(weights.strided_index(i)))[NORM2] = 0.1f;
}
if (!random_init)
{
// simple initialization
for (int i = 1; ... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq (%rax), %rcx
movl 0x50(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, 0x94(%rsp)
testb $0x1, 0xac(%rax)
je 0x226254
movl $0x0, 0x90(%rsp)
movl 0x90(%rsp), %eax
cmpl 0x94(%rsp), %eax
jae 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/OjaNewton.cc |
void GD::foreach_feature<update_data, float&, &make_pred(update_data&, float, float&)>(vw&, example&, update_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 0x226b26
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 INTERACTIONS::inner_kernel<update_data, float&, &make_pred(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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>>> c... | 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 0x227ead
jmp 0x227f27
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<update_data, float&, &make_pred(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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>>> c... | 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 0x228f0d
jmp 0x228f87
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<update_data, float&, &update_normalization(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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 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<update_data, float&, &update_normalization(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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 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<update_data, float&, &compute_Zx_and_norm(update_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::basic_string<char, std::char_traits<char>, std::allo... | 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 0x22b90b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<update_data, float&, &compute_Zx_and_norm(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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... | 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 0x22c94d
jmp 0x22c9c7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<update_data, float&, &compute_Zx_and_norm(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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... | 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 0x22d9ad
jmp 0x22da27
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<update_data, float&, &update_Z_and_wbar(update_data&, float, float&)>(vw&, example&, update_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 0x22db16
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<update_data, float&, &update_Z_and_wbar(update_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::basic_string<char, std::char_traits<char>, std::allo... | 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 0x22dc8b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<update_data, float&, &update_Z_and_wbar(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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<c... | 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 0x22ee9d
jmp 0x22ef17
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<update_data, float&, &update_Z_and_wbar(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | 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<update_data, float&, &update_wbar_and_Zx(update_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::basic_string<char, std::char_traits<char>, std::all... | 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 0x2301db
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<update_data, float&, &update_wbar_and_Zx(update_data&, float, float&), false, &void GD::dummy_func<update_data>(update_data&, 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 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 predict_or_learn<true>(baseline&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(baseline& data, single_learner& base, example& ec)
{
// no baseline if check_enabled is true and example contains flag
if (data.check_enabled && !BASELINE::baseline_enabled(&ec))
{
if (is_learn)
base.learn(ec);
else
base.predict(ec);
return;
}
// always do a full... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x1a(%rax)
je 0x233e54
movq 0x20(%rsp), %rdi
callq 0x232e70
testb $0x1, %al
jne 0x233e54
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2af20
jmp 0x2340f7
movq 0x30(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/baseline.cc |
void CLASSWEIGHTS::predict_or_learn<true, 0>(CLASSWEIGHTS::classweights&, LEARNER::learner<char, example>&, example&) | static void predict_or_learn(classweights& cweights, LEARNER::single_learner& base, example& ec)
{
switch (pred_type)
{
case prediction_type::scalar:
ec.weight *= cweights.get_class_weight((uint32_t)ec.l.simple.label);
break;
case prediction_type::multiclass:
ec.weight *= cweights.get_clas... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
cvttss2si 0x6828(%rax), %rax
movl %eax, %esi
callq 0x237b40
movq (%rsp), %rax
mulss 0x6870(%rax), %xmm0
movss %xmm0, 0x6870(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
c... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/classweight.cc |
void CLASSWEIGHTS::predict_or_learn<false, 0>(CLASSWEIGHTS::classweights&, LEARNER::learner<char, example>&, example&) | static void predict_or_learn(classweights& cweights, LEARNER::single_learner& base, example& ec)
{
switch (pred_type)
{
case prediction_type::scalar:
ec.weight *= cweights.get_class_weight((uint32_t)ec.l.simple.label);
break;
case prediction_type::multiclass:
ec.weight *= cweights.get_clas... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
cvttss2si 0x6828(%rax), %rax
movl %eax, %esi
callq 0x237b40
movq (%rsp), %rax
mulss 0x6870(%rax), %xmm0
movss %xmm0, 0x6870(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
c... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/classweight.cc |
void CLASSWEIGHTS::predict_or_learn<false, 4>(CLASSWEIGHTS::classweights&, LEARNER::learner<char, example>&, example&) | static void predict_or_learn(classweights& cweights, LEARNER::single_learner& base, example& ec)
{
switch (pred_type)
{
case prediction_type::scalar:
ec.weight *= cweights.get_class_weight((uint32_t)ec.l.simple.label);
break;
case prediction_type::multiclass:
ec.weight *= cweights.get_clas... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movl 0x6828(%rax), %esi
callq 0x237b40
movq (%rsp), %rax
mulss 0x6870(%rax), %xmm0
movss %xmm0, 0x6870(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2aeb0
addq $0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/classweight.cc |
LEARNER::learner<CLASSWEIGHTS::classweights, example>& LEARNER::learner<CLASSWEIGHTS::classweights, example>::init_learner<LEARNER::learner<char, example>>(CLASSWEIGHTS::classweights*, LEARNER::learner<char, example>*, void (*)(CLASSWEIGHTS::classweights&, LEARNER::learner<char, example>&, example&), void (*)(CLASSWEIG... | static learner<T, E>& init_learner(T* dat, L* base, void (*learn)(T&, L&, E&), void (*predict)(T&, L&, E&), size_t ws,
prediction_type::prediction_type_t pred_type)
{
learner<T, E>& ret = calloc_or_throw<learner<T, E> >();
if (base != nullptr)
{ // a reduction
ret = *(learner<T, E>*)(base);
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
callq 0x237970
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x237840
movq 0x28(%rsp), %rsi
movq (%rsp), %rdi
movl $0xe9, %edx
callq 0x167a0
movq 0x28(%rsp), %rdi
callq 0x63420... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.h |
shared_data::print_update(bool, unsigned long, float, float, unsigned long, bool, float) | void print_update(bool holdout_set_off, size_t current_pass, float label, float prediction, size_t num_features,
bool progress_add, float progress_arg)
{
std::ostringstream label_buf, pred_buf;
label_buf << std::setw(col_current_label) << std::setfill(' ');
if (label < FLT_MAX)
label_buf << s... | subq $0x428, %rsp # imm = 0x428
movb %r8b, %al
movq %rdi, 0x420(%rsp)
andb $0x1, %sil
movb %sil, 0x41f(%rsp)
movq %rdx, 0x410(%rsp)
movss %xmm0, 0x40c(%rsp)
movss %xmm1, 0x408(%rsp)
movq %rcx, 0x400(%rsp)
andb $0x1, %al
movb %al, 0x3ff(%rsp)
movss %xmm2, 0x3f8(%rsp)
movq 0x420(%rsp), %rax
movq %rax, 0x98(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/global_data.h |
VW::shared_feature_merger::shared_feature_merger_setup(VW::config::options_i&, vw&) | LEARNER::base_learner* shared_feature_merger_setup(config::options_i& options, vw& all)
{
if (!use_reduction(options))
return nullptr;
auto data = scoped_calloc_or_throw<sfm_data>();
auto* base = LEARNER::as_multiline(setup_base(options, all));
auto& learner = LEARNER::init_learner(data, base, predict_or_... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x238840
testb $0x1, %al
jne 0x23890a
movq $0x0, 0x60(%rsp)
jmp 0x2389b2
leaq 0x40(%rsp), %rdi
callq 0x238a60
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3f9d0
movq %rax, 0x18(%rsp)
jmp 0x23892a
movq 0x18(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/shared_feature_merger.cc |
LEARNER::learner<VW::shared_feature_merger::sfm_data, std::vector<example*, std::allocator<example*>>>* calloc_or_throw<LEARNER::learner<VW::shared_feature_merger::sfm_data, std::vector<example*, std::allocator<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 0x239c1b
movq $0x0, 0x1e0(%rsp)
jmp 0x239d51
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x239d41
leaq 0xb9c54(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
boost::program_options::typed_value<std::vector<bool, std::allocator<bool>>, char>* VW::config::options_boost_po::convert_to_boost_value<bool>(std::shared_ptr<VW::config::typed_option<bool>>&) | po::typed_value<std::vector<bool>>* options_boost_po::convert_to_boost_value(std::shared_ptr<typed_option<bool>>& opt)
{
auto value = get_base_boost_value(opt);
if (opt->default_value_supplied())
{
THROW("Using a bool option type acts as a switch, no explicit default value is allowed.")
}
value->default... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq 0x280(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x278(%rsp), %rsi
callq 0x23c180
movq %rax, 0x270(%rsp)
movq 0x278(%rsp), %rdi
callq 0x23c2b0
movq %rax, %rdi
callq 0x23c2c0
testb $0x1, %al
jne 0x23a8f7
jmp 0x23aa04
leaq 0xe8(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.cc |
void VW::config::options_boost_po::add_to_description_impl<VW::config::typelist<>>(std::shared_ptr<VW::config::base_option>, boost::program_options::options_description&) | void options_boost_po::add_to_description_impl<typelist<>>(
std::shared_ptr<base_option>, po::options_description&)
{
THROW("That is an unsupported option type.");
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x16680
leaq 0x58(%rsp), %rdi
leaq 0xc2a4e(%rip), %rsi # 0x2feac3
callq 0x16920
jmp 0x23c07c
movb $0x1, 0x17(%rsp)
movl $0x38, %edi
callq 0x16450
movq %rax, 0x8(%rsp)
leaq 0x18... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.cc |
void VW::config::options_boost_po::add_to_description<unsigned int>(std::shared_ptr<VW::config::typed_option<unsigned int>>, boost::program_options::options_description&) | void options_boost_po::add_to_description(
std::shared_ptr<typed_option<T>> opt, po::options_description& options_description)
{
std::string boost_option_name = opt->m_name;
if (opt->m_short_name != "")
{
boost_option_name += ",";
boost_option_name += opt->m_short_name;
}
options_descript... | subq $0xb8, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, %rax
movq 0x40(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq %rax, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0x243d70
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x80(%rsp), %rdi
callq 0x163c0
movq 0x50(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_boost_po::add_to_description<int>(std::shared_ptr<VW::config::typed_option<int>>, boost::program_options::options_description&) | void options_boost_po::add_to_description(
std::shared_ptr<typed_option<T>> opt, po::options_description& options_description)
{
std::string boost_option_name = opt->m_name;
if (opt->m_short_name != "")
{
boost_option_name += ",";
boost_option_name += opt->m_short_name;
}
options_descript... | subq $0xb8, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, %rax
movq 0x40(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq %rax, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0x2480e0
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x80(%rsp), %rdi
callq 0x163c0
movq 0x50(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<std::vector<int, std::allocator<int>>, char>* VW::config::options_boost_po::get_base_boost_value<int>(std::shared_ptr<VW::config::typed_option<int>>&) | po::typed_value<std::vector<T>>* options_boost_po::get_base_boost_value(std::shared_ptr<typed_option<T>>& opt)
{
auto value = po::value<std::vector<T>>();
if (opt->default_value_supplied())
{
value->default_value({opt->default_value()});
}
return add_notifier(opt, value)->composing();
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x248260
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2480e0
movq %rax, %rdi
callq 0x248270
testb $0x1, %al
jne 0x24817d
jmp 0x248235
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
cal... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<std::vector<float, std::allocator<float>>, char>* VW::config::options_boost_po::get_base_boost_value<float>(std::shared_ptr<VW::config::typed_option<float>>&) | po::typed_value<std::vector<T>>* options_boost_po::get_base_boost_value(std::shared_ptr<typed_option<T>>& opt)
{
auto value = po::value<std::vector<T>>();
if (opt->default_value_supplied())
{
value->default_value({opt->default_value()});
}
return add_notifier(opt, value)->composing();
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x251100
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x250f70
movq %rax, %rdi
callq 0x251110
testb $0x1, %al
jne 0x25100d
jmp 0x2510c7
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
cal... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<std::vector<double, std::allocator<double>>, char>* VW::config::options_boost_po::get_base_boost_value<double>(std::shared_ptr<VW::config::typed_option<double>>&) | po::typed_value<std::vector<T>>* options_boost_po::get_base_boost_value(std::shared_ptr<typed_option<T>>& opt)
{
auto value = po::value<std::vector<T>>();
if (opt->default_value_supplied())
{
value->default_value({opt->default_value()});
}
return add_notifier(opt, value)->composing();
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x255780
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x255600
movq %rax, %rdi
callq 0x255790
testb $0x1, %al
jne 0x25569d
jmp 0x255755
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<std::vector<double, std::allocator<double>>, char>* VW::config::options_boost_po::add_notifier<double>(std::shared_ptr<VW::config::typed_option<double>>&, boost::program_options::typed_value<std::vector<double, std::allocator<double>>, char>*) | po::typed_value<std::vector<T>>* options_boost_po::add_notifier(
std::shared_ptr<typed_option<T>>& opt, po::typed_value<std::vector<T>>* po_value)
{
return po_value->notifier([opt](std::vector<T> final_arguments) {
T first = final_arguments[0];
for (auto const& item : final_arguments)
{
i... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x255530
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
callq 0x258ee0
jmp 0x255964
movq 0x10(%rsp), %rdi
le... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<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>>>>, char>* VW::config::options_boost_po::add_notifier<std::__cxx11::basic_string<char, std::char_tr... | po::typed_value<std::vector<T>>* options_boost_po::add_notifier(
std::shared_ptr<typed_option<T>>& opt, po::typed_value<std::vector<T>>* po_value)
{
return po_value->notifier([opt](std::vector<T> final_arguments) {
T first = final_arguments[0];
for (auto const& item : final_arguments)
{
i... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x25e9a0
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
callq 0x260610
jmp 0x25ee64
movq 0x10(%rsp), %rdi
le... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
bool VW::config::options_boost_po::add_if_t<bool>(std::shared_ptr<VW::config::base_option>, boost::program_options::options_description&) | bool options_boost_po::add_if_t(std::shared_ptr<base_option> opt, po::options_description& options_description)
{
if (opt->m_type_hash == typeid(T).hash_code())
{
auto typed = std::dynamic_pointer_cast<typed_option<T>>(opt);
add_to_description(typed, options_description);
return true;
}
re... | subq $0x88, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rax, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x4c750
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x130d91(%rip), %rdi # 0x391f28
callq 0x579c0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_boost_po::add_to_description<std::vector<int, std::allocator<int>>>(std::shared_ptr<VW::config::typed_option<std::vector<int, std::allocator<int>>>>, boost::program_options::options_description&) | void options_boost_po::add_to_description(
std::shared_ptr<typed_option<T>> opt, po::options_description& options_description)
{
std::string boost_option_name = opt->m_name;
if (opt->m_short_name != "")
{
boost_option_name += ",";
boost_option_name += opt->m_short_name;
}
options_descript... | subq $0xb8, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, %rax
movq 0x40(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq %rax, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0x261c10
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x80(%rsp), %rdi
callq 0x163c0
movq 0x50(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<std::vector<int, std::allocator<int>>, char>* VW::config::options_boost_po::get_base_boost_value<int>(std::shared_ptr<VW::config::typed_option<std::vector<int, std::allocator<int>>>>&) | po::typed_value<std::vector<T>>* options_boost_po::get_base_boost_value(
std::shared_ptr<typed_option<std::vector<T>>>& opt)
{
auto value = po::value<std::vector<T>>();
if (opt->default_value_supplied())
{
value->default_value(opt->default_value());
}
return add_notifier(opt, value)->compo... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x248260
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x261c10
movq %rax, %rdi
callq 0x261d50
testb $0x1, %al
jne 0x261caa
jmp 0x261d05
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
bool VW::config::options_boost_po::add_if_t<std::vector<double, std::allocator<double>>>(std::shared_ptr<VW::config::base_option>, boost::program_options::options_description&) | bool options_boost_po::add_if_t(std::shared_ptr<base_option> opt, po::options_description& options_description)
{
if (opt->m_type_hash == typeid(T).hash_code())
{
auto typed = std::dynamic_pointer_cast<typed_option<T>>(opt);
add_to_description(typed, options_description);
return true;
}
re... | subq $0x88, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rax, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x4c750
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x12ad29(%rip), %rdi # 0x3912f0
callq 0x579c0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_boost_po::add_to_description_impl<VW::config::typelist<std::vector<char, std::allocator<char>>, 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>>>>>>(std::shar... | void add_to_description_impl(std::shared_ptr<base_option> opt, po::options_description& options_description)
{
if (add_if_t<typename TTypes::head>(opt, options_description))
{
return;
}
add_to_description_impl<typename TTypes::tail>(opt, options_description);
} | subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x23c650
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x268000
movb %al, 0x2f(%rsp)
jmp 0x2666... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_boost_po::add_to_description<std::vector<double, std::allocator<double>>>(std::shared_ptr<VW::config::typed_option<std::vector<double, std::allocator<double>>>>, boost::program_options::options_description&) | void options_boost_po::add_to_description(
std::shared_ptr<typed_option<T>> opt, po::options_description& options_description)
{
std::string boost_option_name = opt->m_name;
if (opt->m_short_name != "")
{
boost_option_name += ",";
boost_option_name += opt->m_short_name;
}
options_descript... | subq $0xb8, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, %rax
movq 0x40(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq %rax, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0x266b00
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x80(%rsp), %rdi
callq 0x163c0
movq 0x50(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
boost::program_options::typed_value<std::vector<double, std::allocator<double>>, char>* VW::config::options_boost_po::get_base_boost_value<double>(std::shared_ptr<VW::config::typed_option<std::vector<double, std::allocator<double>>>>&) | po::typed_value<std::vector<T>>* options_boost_po::get_base_boost_value(
std::shared_ptr<typed_option<std::vector<T>>>& opt)
{
auto value = po::value<std::vector<T>>();
if (opt->default_value_supplied())
{
value->default_value(opt->default_value());
}
return add_notifier(opt, value)->compo... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x255780
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x266b00
movq %rax, %rdi
callq 0x266c40
testb $0x1, %al
jne 0x266b9a
jmp 0x266bf5
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.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.