name string | code string | asm string | file string |
|---|---|---|---|
void get_top_weights<dense_parameters>(vw*, int, int, std::vector<feature, std::allocator<feature>>&, dense_parameters&) | void get_top_weights(vw *all, int top_words_count, int topic, std::vector<feature> &output, T &weights)
{
uint64_t length = (uint64_t)1 << all->num_bits;
// get top features for this topic
auto cmp = [](feature left, feature right) { return left.x > right.x; };
std::priority_queue<feature, std::vector<feature>... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movl %esi, 0x11c(%rsp)
movl %edx, 0x118(%rsp)
movq %rcx, 0x110(%rsp)
movq %r8, 0x108(%rsp)
movq 0x120(%rsp), %rax
movb 0x50(%rax), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x100(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
movq $0x0, 0xd0(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
void compute_coherence_metrics<dense_parameters>(lda&, dense_parameters&) | void compute_coherence_metrics(lda &l, T &weights)
{
uint64_t length = (uint64_t)1 << l.all->num_bits;
std::vector<std::vector<feature_pair>> topics_word_pairs;
topics_word_pairs.resize(l.topics);
int top_words_count = 10; // parameterize and check
for (size_t topic = 0; topic < l.topics; topic++)
{
... | subq $0x448, %rsp # imm = 0x448
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movq 0x440(%rsp), %rax
movq 0x188(%rax), %rax
movb 0x50(%rax), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x430(%rsp)
leaq 0x418(%rsp), %rdi
movq %rdi, 0xf0(%rsp)
callq 0x134a40
movq 0xf0(%rsp), %rdi
movq 0x440(%rsp), %rax
movq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
void end_examples<sparse_parameters>(lda&, sparse_parameters&) | void end_examples(lda &l, T &weights)
{
for (typename T::iterator iter = weights.begin(); iter != weights.end(); ++iter)
{
float decay_component =
l.decay_levels.last() - l.decay_levels.end()[(int)(-1 - l.example_t + (&(*iter))[l.all->lda])];
float decay = fmin(1.f, correctedExp(decay_component));
... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x6edc0
movl %edx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x68(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x6ee10
movl %edx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movq 0x38(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
void ldamath::expdigammify<float, (lda_math_mode)2>(vw&, float*, float, float)::'lambda'(float)::operator()(float) const | inline void expdigammify<float, USE_SIMD>(vw &all, float *gamma, float threshold, float)
{
#if defined(HAVE_SIMD_MATHMODE)
vexpdigammify(all, gamma, threshold);
#else
// Do something sensible if SIMD math isn't available:
expdigammify<float, USE_FAST_APPROX>(all, gamma, threshold, 0.0);
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movss 0x4(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x1285f0
movq (%rsp), %rax
subss (%rax), %xmm0
callq 0x12dee0
movaps %xmm0, %xmm1
movss 0x8(%rsp), %xmm0
callq 0x124070
addq $0x18, %rsp
retq
n... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
void ldamath::expdigammify<float, (lda_math_mode)1>(vw&, float*, float, float)::'lambda'(float)::operator()(float) const | inline void expdigammify<float, USE_SIMD>(vw &all, float *gamma, float threshold, float)
{
#if defined(HAVE_SIMD_MATHMODE)
vexpdigammify(all, gamma, threshold);
#else
// Do something sensible if SIMD math isn't available:
expdigammify<float, USE_FAST_APPROX>(all, gamma, threshold, 0.0);
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movss 0x4(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x128610
movq (%rsp), %rax
subss (%rax), %xmm0
callq 0x12dfc0
movaps %xmm0, %xmm1
movss 0x8(%rsp), %xmm0
callq 0x124070
addq $0x18, %rsp
retq
n... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
void ldamath::expdigammify_2<float, (lda_math_mode)0>(vw&, float*, float*, float) | inline void expdigammify_2<float, USE_SIMD>(vw &all, float *gamma, float *norm, const float threshold)
{
#if defined(HAVE_SIMD_MATHMODE)
vexpdigammify_2(all, gamma, norm, threshold);
#else
// Do something sensible if SIMD math isn't available:
expdigammify_2<float, USE_FAST_APPROX>(all, gamma, norm, threshold);
#... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movss 0xc(%rsp), %xmm0
callq 0x11f4c0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
void ldamath::expdigammify_2<float, (lda_math_mode)2>(vw&, float*, float*, float)::'lambda'(float, float)::operator()(float, float) const | inline void expdigammify_2<float, USE_SIMD>(vw &all, float *gamma, float *norm, const float threshold)
{
#if defined(HAVE_SIMD_MATHMODE)
vexpdigammify_2(all, gamma, norm, threshold);
#else
// Do something sensible if SIMD math isn't available:
expdigammify_2<float, USE_FAST_APPROX>(all, gamma, norm, threshold);
#... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x1285f0
subss 0x8(%rsp), %xmm0
callq 0x12dee0
movaps %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
callq 0x124070
addq $0x18, %rsp
retq
nopl (%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
set_initial_lda_wrapper<sparse_parameters>::func(float&, initial_weights&, unsigned long) | static void func(weight &w, initial_weights &iw, uint64_t index)
{
uint32_t lda = iw._lda;
weight initial_random = iw._initial_random;
if (iw._random)
{
weight *pw = &w;
for (size_t i = 0; i != lda; ++i, ++index) pw[i] = (float)(-log(merand48(index) + 1e-6) + 1.0f) * initial_random;
}
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x12f4dd
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/lda_core.cc |
initial_weights* calloc_or_throw<initial_weights>(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 0x12f52b
movq $0x0, 0x1e0(%rsp)
jmp 0x12f661
movq 0x1d8(%rsp), %rdi
movl $0x14, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x12f651
leaq 0x1c4344(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
save_load(gdmf&, io_buf&, bool, bool) | void save_load(gdmf& d, io_buf& model_file, bool read, bool text)
{
vw& all = *d.all;
uint64_t length = (uint64_t)1 << all.num_bits;
if (read)
{
initialize_regressor(all);
if (all.random_weights)
{
uint32_t stride = all.weights.stride();
if (all.weights.sparse)
all.weights.sparse... | subq $0x238, %rsp # imm = 0x238
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
andb $0x1, %cl
movb %cl, 0x227(%rsp)
andb $0x1, %al
movb %al, 0x226(%rsp)
movq 0x230(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x218(%rsp)
movq 0x218(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, %ecx
movl... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_mf.cc |
gd_mf_setup(VW::config::options_i&, vw&) | base_learner* gd_mf_setup(options_i& options, vw& all)
{
auto data = scoped_calloc_or_throw<gdmf>();
bool bfgs = false;
bool conjugate_gradient = false;
option_group_definition gf_md_options("Gradient Descent Matrix Factorization");
gf_md_options.add(make_option("rank", data->rank).keep().help("rank for matr... | subq $0xce8, %rsp # imm = 0xCE8
movq %rdi, 0xcd8(%rsp)
movq %rsi, 0xcd0(%rsp)
leaq 0xcc0(%rsp), %rdi
callq 0x142940
movb $0x0, 0xcbf(%rsp)
movb $0x0, 0xcbe(%rsp)
leaq 0xc5f(%rsp), %rdi
movq %rdi, 0x168(%rsp)
callq 0x17200
movq 0x168(%rsp), %rdx
leaq 0x1b94d2(%rip), %rsi # 0x2f8b2a
leaq 0xc60(%rsp), %rdi
c... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_mf.cc |
float mf_predict<dense_parameters>(gdmf&, example&, dense_parameters&) | float mf_predict(gdmf& d, example& ec, T& weights)
{
vw& all = *d.all;
label_data& ld = ec.l.simple;
float prediction = ld.initial;
for (string& i : d.all->pairs)
{
ec.num_features -= ec.feature_space[(int)i[0]].size() * ec.feature_space[(int)i[1]].size();
ec.num_features += ec.feature_space[(int)i[0... | subq $0x308, %rsp # imm = 0x308
movq %rdi, 0x300(%rsp)
movq %rsi, 0x2f8(%rsp)
movq %rdx, 0x2f0(%rsp)
movq 0x300(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x2e8(%rsp)
movq 0x2f8(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x2e0(%rsp)
movq 0x2e0(%rsp), %rax
movss 0x8(%rax), %xmm0
movss %x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_mf.cc |
void mf_train<sparse_parameters>(gdmf&, example&, sparse_parameters&) | void mf_train(gdmf& d, example& ec, T& weights)
{
vw& all = *d.all;
label_data& ld = ec.l.simple;
// use final prediction to get update size
// update = eta_t*(y-y_hat) where eta_t = eta/(3*t^p) * importance weight
float eta_t = all.eta / powf((float)all.sd->t + ec.weight, (float)all.power_t) / 3.f * ec.weig... | subq $0x2b8, %rsp # imm = 0x2B8
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movq %rdx, 0x2a0(%rsp)
movq 0x2b0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x298(%rsp)
movq 0x2a8(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x290(%rsp)
movq 0x298(%rsp), %rax
movss 0x3560(%rax), %xmm0
movss... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_mf.cc |
unsigned int* calloc_or_throw<unsigned int>(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 0x1430ab
movq $0x0, 0x1e0(%rsp)
jmp 0x1431e1
movq 0x1d8(%rsp), %rdi
movl $0x4, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1431d1
leaq 0x1b07c4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
gdmf* calloc_or_throw<gdmf>(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 0x1432bb
movq $0x0, 0x1e0(%rsp)
jmp 0x1433f1
movq 0x1d8(%rsp), %rdi
movl $0x40, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1433e1
leaq 0x1b05b4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
mf_setup(VW::config::options_i&, vw&) | base_learner* mf_setup(options_i& options, vw& all)
{
auto data = scoped_calloc_or_throw<mf>();
option_group_definition new_options("Matrix Factorization Reduction");
new_options.add(make_option("new_mf", data->rank).keep().help("rank for reduction-based matrix factorization"));
options.add_and_parse(new_option... | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x228(%rsp)
movq %rsi, 0x220(%rsp)
leaq 0x210(%rsp), %rdi
callq 0x1448d0
leaq 0x1b7(%rsp), %rdi
movq %rdi, 0x78(%rsp)
callq 0x17200
movq 0x78(%rsp), %rdx
leaq 0x1b4cd0(%rip), %rsi # 0x2f8ca2
leaq 0x1b8(%rsp), %rdi
callq 0x16d50
jmp 0x143fe1
leaq 0x1d8(%rsp), %rdi... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/mf.cc |
void predict<false>(mf&, LEARNER::learner<char, example>&, example&) | void predict(mf& data, single_learner& base, example& ec)
{
float prediction = 0;
if (cache_sub_predictions)
data.sub_predictions.resize(2 * data.rank + 1);
// predict from linear terms
base.predict(ec);
// store linear prediction
if (cache_sub_predictions)
data.sub_predictions[0] = ec.partial_pre... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x4c(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2aeb0
movq 0x50(%rsp), %rax
movss 0x68a8(%rax), %xmm0
addss 0x4c(%rsp), %xmm0
movss %xmm0, 0x4c(%rsp)
movq 0x6... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/mf.cc |
mf* calloc_or_throw<mf>(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 0x144e0b
movq $0x0, 0x1e0(%rsp)
jmp 0x144f41
movq 0x1d8(%rsp), %rdi
movl $0xf8, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x144f31
leaq 0x1aea64(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
LEARNER::learner<mf, example>& LEARNER::learner<mf, example>::init_learner<LEARNER::learner<char, example>>(mf*, LEARNER::learner<char, example>*, void (*)(mf&, LEARNER::learner<char, example>&, example&), void (*)(mf&, LEARNER::learner<char, example>&, example&), unsigned long, prediction_type::prediction_type_t) | 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 0x145490
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x145360
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 |
regularizer_direction_magnitude(vw&, bfgs&, float) | double regularizer_direction_magnitude(vw& all, bfgs& b, float regularizer)
{
// compute direction magnitude
double ret = 0.;
if (regularizer == 0.)
return ret;
if (all.weights.sparse)
return regularizer_direction_magnitude(all, b, regularizer, all.weights.sparse_weights);
else
return regularize... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14597e
jp 0x14597e
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x1459ec
movq 0x18(%rsp), %rax
testb $0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
wolfe_eval(vw&, bfgs&, float*, double, double, double, double, int&, double&) | double wolfe_eval(vw& all, bfgs& b, float* mem, double loss_sum, double previous_loss_sum, double step_size,
double importance_weight_sum, int& origin, double& wolfe1)
{
if (all.weights.sparse)
return wolfe_eval(all, b, mem, loss_sum, previous_loss_sum, step_size, importance_weight_sum, origin, wolfe1,
... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x48(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0x145c61
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
process_example(vw&, bfgs&, example&) | void process_example(vw& all, bfgs& b, example& ec)
{
label_data& ld = ec.l.simple;
if (b.first_pass)
b.importance_weight_sum += ec.weight;
/********************************************************************/
/* I) GRADIENT CALCULATION ******************************************/
/**********************... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0x110(%rax)
je 0x147137
movq 0x30(%rsp), %rax
movss 0x6870(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x38(%rsp), %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
end_pass(bfgs&) | void end_pass(bfgs& b)
{
vw* all = b.all;
if (b.current_pass <= b.final_pass)
{
if (b.current_pass < b.final_pass)
{
int status = process_pass(*all, b);
// reaching the max number of passes regardless of convergence
if (b.final_pass == b.current_pass)
{
b.all->trace_messa... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x80(%rsp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x1476ed
movq 0x80(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x80(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1476d1
movq 0x78(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
bfgs_setup(VW::config::options_i&, vw&) | base_learner* bfgs_setup(options_i& options, vw& all)
{
auto b = scoped_calloc_or_throw<bfgs>();
bool conjugate_gradient = false;
bool bfgs_option = false;
option_group_definition bfgs_outer_options("LBFGS and Conjugate Gradient options");
bfgs_outer_options.add(
make_option("conjugate_gradient", conjug... | subq $0x8c8, %rsp # imm = 0x8C8
movq %rdi, 0x8b8(%rsp)
movq %rsi, 0x8b0(%rsp)
leaq 0x8a0(%rsp), %rdi
callq 0x14fbb0
movb $0x0, 0x89f(%rsp)
movb $0x0, 0x89e(%rsp)
leaq 0x83f(%rsp), %rdi
movq %rdi, 0x128(%rsp)
callq 0x17200
movq 0x128(%rsp), %rdx
leaq 0x1b0faf(%rip), %rsi # 0x2f91d7
leaq 0x840(%rsp), %rdi
c... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.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 |
double regularizer_direction_magnitude<sparse_parameters>(vw&, bfgs&, double, sparse_parameters&) | double regularizer_direction_magnitude(vw& /* all */, bfgs& b, double regularizer, T& weights)
{
double ret = 0.;
if (b.regularizers == nullptr)
for (typename T::iterator iter = weights.begin(); iter != weights.end(); ++iter)
ret += regularizer * (&(*iter))[W_DIR] * (&(*iter))[W_DIR];
else
{
for ... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movsd %xmm0, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xb0(%rsp)
movq 0xc8(%rsp), %rax
cmpq $0x0, 0xd8(%rax)
jne 0x14966f
movq 0xb8(%rsp), %rdi
callq 0x6edc0
movl %edx, 0x98(%rsp)
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
void bfgs_iter_start<sparse_parameters>(vw&, bfgs&, float*, int&, double, int&, sparse_parameters&) | void bfgs_iter_start(vw& all, bfgs& b, float* mem, int& lastj, double importance_weight_sum, int& origin, T& weights)
{
double g1_Hg1 = 0.;
double g1_g1 = 0.;
origin = 0;
for (typename T::iterator w = weights.begin(); w != weights.end(); ++w)
{
float* mem1 = mem + (w.index() >> weights.stride_shift()) * ... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movsd %xmm0, 0xb0(%rsp)
movq %r8, 0xa8(%rsp)
movq %r9, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
movq $0x0, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movl $0x0, (%rax)
movq 0xa0(%rsp), %rdi
callq 0x6edc0
movl %edx, 0x78(%rsp)
movq %r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
void bfgs_iter_start<dense_parameters>(vw&, bfgs&, float*, int&, double, int&, dense_parameters&) | void bfgs_iter_start(vw& all, bfgs& b, float* mem, int& lastj, double importance_weight_sum, int& origin, T& weights)
{
double g1_Hg1 = 0.;
double g1_g1 = 0.;
origin = 0;
for (typename T::iterator w = weights.begin(); w != weights.end(); ++w)
{
float* mem1 = mem + (w.index() >> weights.stride_shift()) * ... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movsd %xmm0, 0xa0(%rsp)
movq %r8, 0x98(%rsp)
movq %r9, 0x90(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
movq 0x98(%rsp), %rax
movl $0x0, (%rax)
movq 0x90(%rsp), %rsi
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
double wolfe_eval<sparse_parameters>(vw&, bfgs&, float*, double, double, double, double, int&, double&, sparse_parameters&) | double wolfe_eval(vw& all, bfgs& b, float* mem, double loss_sum, double previous_loss_sum, double step_size,
double importance_weight_sum, int& origin, double& wolfe1, T& weights)
{
double g0_d = 0.;
double g1_d = 0.;
double g1_Hg1 = 0.;
double g1_g1 = 0.;
for (typename T::iterator w = weights.begin(); w... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movsd %xmm0, 0xe8(%rsp)
movsd %xmm1, 0xe0(%rsp)
movsd %xmm2, 0xd8(%rsp)
movsd %xmm3, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq %r9, 0xb8(%rsp)
movq $0x0, 0xb0(%rsp)
movq $0x0, 0xa8(%rsp)
movq $... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
double wolfe_eval<dense_parameters>(vw&, bfgs&, float*, double, double, double, double, int&, double&, dense_parameters&) | double wolfe_eval(vw& all, bfgs& b, float* mem, double loss_sum, double previous_loss_sum, double step_size,
double importance_weight_sum, int& origin, double& wolfe1, T& weights)
{
double g0_d = 0.;
double g1_d = 0.;
double g1_Hg1 = 0.;
double g1_g1 = 0.;
for (typename T::iterator w = weights.begin(); w... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movsd %xmm0, 0xd8(%rsp)
movsd %xmm1, 0xd0(%rsp)
movsd %xmm2, 0xc8(%rsp)
movsd %xmm3, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xa8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
void finalize_preconditioner<sparse_parameters>(vw&, bfgs&, float, sparse_parameters&) | void finalize_preconditioner(vw& /* all */, bfgs& b, float regularization, T& weights)
{
float max_hessian = 0.f;
if (b.regularizers == nullptr)
for (typename T::iterator w = weights.begin(); w != weights.end(); ++w)
{
(&(*w))[W_COND] += regularization;
if ((&(*w))[W_COND] > max_hessian)
... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movss %xmm0, 0x114(%rsp)
movq %rdx, 0x108(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x104(%rsp)
movq 0x118(%rsp), %rax
cmpq $0x0, 0xd8(%rax)
jne 0x14e3da
movq 0x108(%rsp), %rdi
callq 0x6edc0
movl %edx, 0xe8(%rsp)
movq %rax, 0xe0(%rsp)
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
void regularizer_to_weight<sparse_parameters>(vw&, bfgs&, sparse_parameters&) | void regularizer_to_weight(vw& /* all */, bfgs& b, T& weights)
{
if (b.regularizers != nullptr)
{
for (typename T::iterator w = weights.begin(); w != weights.end(); ++w)
{
uint64_t i = w.index() >> weights.stride_shift();
(&(*w))[W_COND] = b.regularizers[2 * i];
*w = b.regularizers[2 * i +... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x14f4fb
movq 0x60(%rsp), %rdi
callq 0x6edc0
movl %edx, 0x48(%rsp)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0x60(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
void learn<false>(bfgs&, LEARNER::learner<char, char>&, example&) | void learn(bfgs& b, base_learner& base, example& ec)
{
vw* all = b.all;
assert(ec.in_use);
if (b.current_pass <= b.final_pass)
{
if (test_example(ec))
predict<audit>(b, base, ec);
else
process_example(*all, b, ec);
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x14fd33
movq 0x10(%rsp), %rdi
callq 0x145760
testb $0x1, %al
jne 0x14fd07
jmp 0x14fd... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bfgs.cc |
void GD::foreach_feature<float, float&, &add_grad(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_traits<char>, std::allocator<char>>>>&, bool... | 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 0x15036b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &add_grad(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*), dense_pa... | 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&, &add_grad(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*), dense_parameters>... | 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 0x1525dd
jmp 0x152657
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &add_precond(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>>>>&, boo... | 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 0x152acb
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<float, float&, &add_precond(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*), sparse_paramet... | 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 0x153b0d
jmp 0x153b87
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &add_DIR(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>>>>&, bool, e... | 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 0x15505b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
bfgs* calloc_or_throw<bfgs>(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 0x15727b
movq $0x0, 0x1e0(%rsp)
jmp 0x1573b1
movq 0x1d8(%rsp), %rdi
movl $0x118, %esi # imm = 0x118
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1573a1
leaq 0x19c5f4(%rip), %rax # 0x2f389f
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
noop_setup(VW::config::options_i&, vw&) | LEARNER::base_learner* noop_setup(options_i& options, vw&)
{
bool noop = false;
option_group_definition new_options("Noop Learner");
new_options.add(make_option("noop", noop).keep().help("do no learning"));
options.add_and_parse(new_options);
if (!noop)
return nullptr;
return make_base(LEARNER::init_l... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x1a8(%rsp)
movq %rsi, 0x1a0(%rsp)
movb $0x0, 0x19f(%rsp)
leaq 0x13f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x17200
movq 0x30(%rsp), %rdx
leaq 0x1a192d(%rip), %rsi # 0x2f93ca
leaq 0x140(%rsp), %rdi
callq 0x16d50
jmp 0x157aac
leaq 0x160(%rsp), %rdi
leaq 0x140(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/noop.cc |
LEARNER::learner<char, example>& LEARNER::learner<char, example>::init_learner<LEARNER::learner<char, char>>(char*, LEARNER::learner<char, char>*, void (*)(char&, LEARNER::learner<char, char>&, example&), void (*)(char&, LEARNER::learner<char, char>&, example&), unsigned long, prediction_type::prediction_type_t) | 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 0x157fc0
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x157ea0
movq 0x28(%rsp), %rsi
movq (%rsp), %rdi
movl $0xe9, %edx
callq 0x167a0
movq 0x28(%rsp), %rdi
callq 0x11615... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/learner.h |
VW::copy_example_data(bool, example*, example*) | void copy_example_data(bool audit, example* dst, example* src)
{
// std::cerr << "copy_example_data dst = " << dst << std::endl;
copy_example_metadata(audit, dst, src);
// copy feature data
copy_array(dst->indices, src->indices);
for (namespace_index c : src->indices) dst->feature_space[c].deep_copy_from(src... | subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
andb $0x1, %al
movzbl %al, %edi
callq 0x15b7f0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x144860
movq 0x20(%rsp), %rax
movq %rax, 0x18... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/example.cc |
features::truncate_to(features_value_iterator const&) | void truncate_to(const features_value_iterator& pos)
{
ssize_t i = pos._begin - values.begin();
values.end() = pos._begin;
if (indicies.end() != indicies.begin())
indicies.end() = indicies.begin() + i;
if (space_names.begin() != space_names.end())
{
free_space_names(i);
space_nam... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
callq 0x72c60
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, 0x40(%rsp)
movq 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/feature_group.h |
void GD::foreach_feature<full_features_and_source, unsigned long, &vec_ffs_store(full_features_and_source&, float, unsigned long)>(vw&, example&, full_features_and_source&) | 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 0x15c886
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 |
int order_features<feature_slice>(void const*, void const*) | inline int order_features(const void* first, const void* second)
{
if (((T*)first)->weight_index != ((T*)second)->weight_index)
return (int)(((T*)first)->weight_index - ((T*)second)->weight_index);
else if (((T*)first)->x > ((T*)second)->x)
return 1;
else
return -1;
} | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x15d1c6
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
subq 0x8(%rcx), %rax
movl %eax, -0x4(%rsp)
jmp 0x15d1eb
movq -0x10(%rsp), %rax
movss (%rax), %xmm0
movq -0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/feature_group.h |
v_array<feature>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq 0x1f8(%rsp), %rax
je 0x15d8ac
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sa... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
void GD::foreach_feature<features_and_source, unsigned long, &vec_store(features_and_source&, float, unsigned long), 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_tra... | 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 0x15df2b
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<features_and_source, unsigned long, &vec_store(features_and_source&, float, unsigned long), false, &void GD::dummy_func<features_and_source>(features_and_source&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string... | 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<full_features_and_source, unsigned long, &vec_ffs_store(full_features_and_source&, float, unsigned long), false, &void GD::dummy_func<full_features_and_source>(full_features_and_source&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx1... | 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 0x1614cd
jmp 0x161547
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
is_test_only(unsigned int, unsigned int, unsigned int, bool, unsigned int) | bool is_test_only(uint32_t counter, uint32_t period, uint32_t after, bool holdout_off,
uint32_t target_modulus) // target should be 0 in the normal case, or period-1 in the case that emptylines separate
// examples
{
if (holdout_off)
return false;
if (after == 0) // hold out ... | movb %cl, %al
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
andb $0x1, %al
movb %al, -0x11(%rsp)
movl %r8d, -0x18(%rsp)
testb $0x1, -0x11(%rsp)
je 0x162677
movb $0x0, -0x1(%rsp)
jmp 0x1626a8
cmpl $0x0, -0x10(%rsp)
jne 0x162697
movl -0x8(%rsp), %eax
xorl %edx, %edx
divl -0xc(%rsp)
cmpl -0x18(%rsp), ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
cache_numbits(io_buf*, int) | uint32_t cache_numbits(io_buf* buf, int filepointer)
{
try
{
size_t v_length;
buf->read_file(filepointer, (char*)&v_length, sizeof(v_length));
if (v_length > 61)
THROW("cache version too long, cache file is probably invalid");
if (v_length == 0)
THROW("cache version too short, cache fil... | subq $0x788, %rsp # imm = 0x788
movq %rdi, 0x778(%rsp)
movl %esi, 0x774(%rsp)
movq 0x778(%rsp), %rdi
movl 0x774(%rsp), %esi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq 0x768(%rsp), %rdx
movl $0x8, %ecx
callq *%rax
jmp 0x1628ed
cmpq $0x3d, 0x768(%rsp)
jbe 0x162a24
leaq 0x5d0(%rsp), %rdi
callq 0x16680
jmp 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
make_write_cache(vw&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool) | void make_write_cache(vw& all, string& newname, bool quiet)
{
io_buf* output = all.p->output;
if (output->files.size() != 0)
{
all.trace_message << "Warning: you tried to make two write caches. Only the first one will be made." << endl;
return;
}
string temp = newname + string(".writing");
push_ma... | subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
andb $0x1, %al
movb %al, 0x137(%rsp)
movq 0x140(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x210(%rax), %rax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rdi
addq $0x30, %rdi
callq 0x2e240
cmpq $0x0, %rax
je 0x163973
movq 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
addgrams(vw&, unsigned long, unsigned long, features&, unsigned long, v_array<unsigned long>&, unsigned long) | void addgrams(vw& all, size_t ngram, size_t skip_gram, features& fs, size_t initial_length, v_array<size_t>& gram_mask,
size_t skips)
{
if (ngram == 0 && gram_mask.last() < initial_length)
{
size_t last = initial_length - gram_mask.last();
for (size_t i = 0; i < last; i++)
{
uint64_t new_index... | subq $0x178, %rsp # imm = 0x178
movq 0x180(%rsp), %rax
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
movq %rdx, 0x160(%rsp)
movq %rcx, 0x158(%rsp)
movq %r8, 0x150(%rsp)
movq %r9, 0x148(%rsp)
cmpq $0x0, 0x168(%rsp)
jne 0x166583
movq 0x148(%rsp), %rdi
callq 0x168cf0
cmpq 0x150(%rsp), %rax
jae 0x166583
movq 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
feature_limit(vw&, example*) | void feature_limit(vw& all, example* ex)
{
for (namespace_index index : ex->indices)
if (all.limit[index] < ex->feature_space[index].size())
{
features& fs = ex->feature_space[index];
fs.sort(all.parse_mask);
unique_features(fs, all.limit[index]);
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x72bf0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x72c30
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x166954
movq 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
VW::add_constant_feature(vw&, example*) | void add_constant_feature(vw& vw, example* ec)
{
ec->indices.push_back(constant_namespace);
ec->feature_space[constant_namespace].push_back(1, constant);
ec->total_sum_feat_sq++;
ec->num_features++;
if (vw.audit || vw.hash_inv)
ec->feature_space[constant_namespace].space_names.push_back(audit_strings_ptr(... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x192cd5(%rip), %rsi # 0x2f9e7f
callq 0x11eeb0
movq 0x38(%rsp), %rdi
addq $0x20, %rdi
addq $0x3400, %rdi # imm = 0x3400
movss 0x18c4fd(%rip), %xmm0 # 0x2f36c4
movl $0xb1c55c, %esi # imm = 0xB1C55C
callq 0x11ef... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
VW::parse_example_label(vw&, example&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void parse_example_label(vw& all, example& ec, string label)
{
v_array<substring> words = v_init<substring>();
char* cstr = (char*)label.c_str();
substring str = {cstr, cstr + label.length()};
tokenize(' ', str, words);
all.p->lp.parse_label(all.p, all.sd, &ec.l, words);
words.clear();
words.delete_v();
} | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4fe10
movq 0x8(%rsp), %rdi
callq 0x163a0
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x16ed0
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
free_parser(vw&) | void free_parser(vw& all)
{
all.p->words.delete_v();
all.p->name.delete_v();
if (all.ngram_strings.size() > 0)
all.p->gram_mask.delete_v();
io_buf* output = all.p->output;
if (output != nullptr)
{
output->finalname.delete_v();
output->currentname.delete_v();
}
while (! all.p->example_pool... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4ca70
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
callq 0x4ca70
movq 0x20(%rsp), %rdi
addq $0x6b8, %rdi # imm = 0x6B8
callq 0x1f7d0
cmpq $0x0, %rax
jbe 0x168315
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parser.cc |
int read_features_json<true>(vw*, v_array<example*>&) | int read_features_json(vw* all, v_array<example*>& examples)
{
// Keep reading lines until a valid set of examples is produced.
bool reread;
do
{
reread = false;
char* line;
size_t num_chars;
size_t num_chars_initial = read_features(all, line, num_chars);
if (num_chars_initial < 1)
re... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2e96f0
movq %rax, (%rsp)
cmpq $0x1, (%rsp)
jae 0x16892c
movq (%rsp), %rax
movl %eax, 0x34(%rsp)
jmp 0x168979
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
void line_to_examples_json<false>(vw*, char*, unsigned long, v_array<example*>&) | void line_to_examples_json(vw* all, char* line, size_t num_chars, v_array<example*>& examples)
{
bool good_example = parse_line_json<audit>(all, line, num_chars, examples);
if (!good_example)
{
VW::return_multiple_example(*all, examples);
examples.push_back(&VW::get_unused_example(all));
return;
}
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x176530
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x168be5
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
VW::ptr_queue<example>::push(example*) | void push(T* item)
{
std::unique_lock<std::mutex> lock(mut);
while (object_queue.size() == max_size)
{
is_not_full.wait(lock);
}
object_queue.push(item);
lock.unlock();
is_not_empty.notify_all();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x58, %rsi
leaq 0x18(%rsp), %rdi
callq 0x1687b0
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x16a280
movq (%rsp), %rcx
cmpq (%rcx), %rax
jne 0x1691a2
movq (%rsp), %rdi
addq $0x88, %rdi
leaq 0x18(%rsp), %rsi
callq 0x16... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/queue.h |
bool parse_line_json<true>(vw*, char*, unsigned long, v_array<example*>&) | bool parse_line_json(vw* all, char* line, size_t num_chars, v_array<example*>& examples)
{
if (all->p->decision_service_json)
{
// Skip lines that do not start with "{"
if (line[0] != '{')
{
return false;
}
DecisionServiceInteraction interaction;
VW::template read_line_decision_servic... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x381(%rax)
je 0x16a412
movq 0xb0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
je 0x16a2ed
movb $0x0, 0xc7(%rsp)
jmp 0x16a446
leaq 0x48(%rsp), %rdi
movq %rd... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
VWReaderHandler<true>::init(vw*, v_array<example*>*, rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>*, char const*, example& (*)(void*), void*) | void init(vw* all, v_array<example*>* examples, rapidjson::InsituStringStream* stream, const char* stream_end,
VW::example_factory_t example_factory, void* example_factory_context)
{
ctx.init(all);
ctx.examples = examples;
ctx.ex = (*examples)[0];
all->p->lp.default_label(&ctx.ex->l);
ctx.s... | subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
callq 0x171cc0
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x20(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
Context<true>::Context() | Context()
{
current_state = &default_state;
root_state = &default_state;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x16cc40
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x10(%rsp)
callq 0x16cc70
movq 0x18(%rsp), %rdi
addq $0x78, %rdi
callq 0x16cc80
jmp 0x16cad3
movq 0x8(%rsp), %rdi
addq $0x88, %rdi
call... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
DefaultState<true>::Key(Context<true>&, char const*, unsigned int, bool) | BaseState<audit>* Key(Context<audit>& ctx, const char* str, rapidjson::SizeType length, bool)
{
ctx.key = str;
ctx.key_length = length;
if (length > 0 && str[0] == '_')
{
// match _label*
if (ctx.key_length >= 6 && !strncmp(str, "_label", 6))
{
if (ctx.key_length >= 7 && ctx... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
Namespace<true>::AddFeature(vw*, char const*) | void AddFeature(vw* all, const char* str)
{
ftrs->push_back(1., VW::hash_feature(*all, str, namespace_hash));
feature_count++;
if (audit)
ftrs->space_names.push_back(audit_strings_ptr(new audit_strings(name, str)));
} | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x17200
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
DefaultState<true>::Ignore(Context<true>&, unsigned int) | BaseState<audit>* Ignore(Context<audit>& ctx, rapidjson::SizeType length)
{
// fast ignore
// skip key + \0 + "
char* head = ctx.stream->src_ + length + 2;
if (head >= ctx.stream_end || *head != ':')
{
ctx.error() << "Expected ':' found '" << *head << "'";
return nullptr;
}
hea... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x60(%rcx), %rax
jae 0x16ef9b
movq 0x20(%rsp), %ra... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
LabelObjectState<true>::EndObject(Context<true>&, unsigned int) | BaseState<audit>* EndObject(Context<audit>& ctx, rapidjson::SizeType)
{
if (found_cb)
{
CB::label* ld = (CB::label*)&ctx.ex->l;
ld->costs.push_back(cb_label);
found_cb = false;
cb_label = {0., 0, 0., 0.};
}
else if (found)
{
count_label(ctx.all->sd, ctx.ex->l.simple.... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x29(%rax)
je 0x16f416
movq (%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x18, ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
LabelObjectState<true>::StartObject(Context<true>&) | BaseState<audit>* StartObject(Context<audit>& ctx)
{
ctx.all->p->lp.default_label(&ctx.ex->l);
// don't allow { { { } } }
if (ctx.previous_state == this)
{
ctx.error() << "invalid label object. nested objected.";
return nullptr;
}
// keep previous state
return_state = ctx.pre... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x338(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rdi
addq $0x6828, %rdi # imm = 0x6828
callq *%rax
movq 0x8(%rsp), %rcx
movq 0x1... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
TextState<true>::String(Context<true>&, char const*, unsigned int, bool) | BaseState<audit>* String(Context<audit>& ctx, const char* str, rapidjson::SizeType length, bool)
{
auto& ns = ctx.CurrentNamespace();
// split into individual features
const char* start = str;
const char* end = str + length;
for (char* p = (char*)str; p != end; p++)
{
switch (*p)
... | subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16e050
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
ArrayState<true>::Float(Context<true>&, float) | BaseState<audit>* Float(Context<audit>& ctx, float f)
{
if (audit)
{
stringstream str;
str << '[' << (array_hash - ctx.CurrentNamespace().namespace_hash) << ']';
ctx.CurrentNamespace().AddFeature(f, array_hash, str.str().c_str());
}
else
ctx.CurrentNamespace().AddFeature(f, ar... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movss %xmm0, 0x1f4(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x16680
leaq 0x78(%rsp), %rdi
movl $0x5b, %esi
callq 0x16af0
movq %rax, 0x30(%rsp)
jmp 0x17072d
movq 0x28(%rsp), %rax
movq 0x10(%rax)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseValue<1u, rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>, VWReaderHandler<true>>(rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>&, VWReaderHandler<true>&) | void ParseValue(InputStream& is, Handler& handler) {
switch (is.Peek()) {
case 'n': ParseNull <parseFlags>(is, handler); break;
case 't': ParseTrue <parseFlags>(is, handler); break;
case 'f': ParseFalse <parseFlags>(is, handler); break;
case '"': ParseString<par... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x171de0
movsbl %al, %eax
movl %eax, 0xc(%rsp)
subl $0x22, %eax
je 0x171ef1
jmp 0x171e74
movl 0xc(%rsp), %eax
subl $0x5b, %eax
je 0x171f1d
jmp 0x171e83
movl 0xc(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/rapidjson/include/rapidjson/reader.h |
void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseTrue<1u, rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>, VWReaderHandler<true>>(rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>&, VWReaderHandler<true>&) | void ParseTrue(InputStream& is, Handler& handler) {
RAPIDJSON_ASSERT(is.Peek() == 't');
is.Take();
if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e'))) {
if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
RAPIDJSON_PARSE_ERROR(kParseErrorTerminat... | subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1720b0
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movb $0x72, 0x57(%rsp)
movq 0x58(%rsp), %rdi
callq 0x171de0
movsbl %al, %eax
movsbl 0x57(%rsp), %ecx
cmpl %ecx, ... | /LAIRLAB[P]vowpal_wabbit/rapidjson/include/rapidjson/reader.h |
unsigned int rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseHex4<rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericInsituStringStream<rapidjson::UTF8<char>>&, unsigned long) | unsigned ParseHex4(InputStream& is, size_t escapeOffset) {
unsigned codepoint = 0;
for (int i = 0; i < 4; i++) {
Ch c = is.Peek();
codepoint <<= 4;
codepoint += static_cast<unsigned>(c);
if (c >= '0' && c <= '9')
codepoint -= '0';
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x1753c6
movq 0x20(%rsp), %rdi
callq 0x171de0
movb %al, 0xf(%rsp)
movl 0x14(%rsp), %eax
shll $0x4, %eax
movl %eax, 0x14(%rsp)
m... | /LAIRLAB[P]vowpal_wabbit/rapidjson/include/rapidjson/reader.h |
bool parse_line_json<false>(vw*, char*, unsigned long, v_array<example*>&) | bool parse_line_json(vw* all, char* line, size_t num_chars, v_array<example*>& examples)
{
if (all->p->decision_service_json)
{
// Skip lines that do not start with "{"
if (line[0] != '{')
{
return false;
}
DecisionServiceInteraction interaction;
VW::template read_line_decision_servic... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x381(%rax)
je 0x1766b2
movq 0xb0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
je 0x17658d
movb $0x0, 0xc7(%rsp)
jmp 0x1766e6
leaq 0x48(%rsp), %rdi
movq %rd... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
void VW::read_line_json<false>(vw&, v_array<example*>&, char*, example& (*)(void*), void*) | void read_line_json(
vw& all, v_array<example*>& examples, char* line, example_factory_t example_factory, void* ex_factory_context)
{
// string line_copy(line);
// destructive parsing
InsituStringStream ss(line);
json_parser<audit>* parser = static_cast<json_parser<audit>*>(all.p->jsonp.get());
VWReaderH... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq %rdx, 0x2b0(%rsp)
movq %rcx, 0x2a8(%rsp)
movq %r8, 0x2a0(%rsp)
movq 0x2b0(%rsp), %rsi
leaq 0x288(%rsp), %rdi
callq 0x16b020
movq 0x2c0(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x388, %rdi # imm = 0x388
callq 0x175af0
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
DefaultState<false>::Float(Context<false>&, float) | BaseState<audit>* Float(Context<audit>& ctx, float f)
{
auto& ns = ctx.CurrentNamespace();
ns.AddFeature(f, VW::hash_feature(*ctx.all, ctx.key, ns.namespace_hash), ctx.key);
return this;
} | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movss %xmm0, 0x84(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rdi
callq 0x1785f0
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movss 0x84(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x88(%rsp), %rax
movq 0x8(%rax), %r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
DefaultState<false>::Key(Context<false>&, char const*, unsigned int, bool) | BaseState<audit>* Key(Context<audit>& ctx, const char* str, rapidjson::SizeType length, bool)
{
ctx.key = str;
ctx.key_length = length;
if (length > 0 && str[0] == '_')
{
// match _label*
if (ctx.key_length >= 6 && !strncmp(str, "_label", 6))
{
if (ctx.key_length >= 7 && ctx... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
Context<false>::error[abi:cxx11]() | std::stringstream& error()
{
if (!error_ptr)
error_ptr.reset(new std::stringstream{});
return *error_ptr;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x16ddd0
testb $0x1, %al
jne 0x1785cd
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x188, %edi # imm = 0x188
callq 0x16940
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x16680
jmp 0x1785a2
movq 0x10(%r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
DefaultState<false>::Ignore(Context<false>&, unsigned int) | BaseState<audit>* Ignore(Context<audit>& ctx, rapidjson::SizeType length)
{
// fast ignore
// skip key + \0 + "
char* head = ctx.stream->src_ + length + 2;
if (head >= ctx.stream_end || *head != ':')
{
ctx.error() << "Expected ':' found '" << *head << "'";
return nullptr;
}
hea... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x60(%rcx), %rax
jae 0x1791cb
movq 0x20(%rsp), %ra... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
LabelObjectState<false>::Float(Context<false>&, float) | BaseState<audit>* Float(Context<audit>& ctx, float v)
{
// simple
if (!_stricmp(ctx.key, "Label"))
{
ctx.ex->l.simple.label = v;
found = true;
}
else if (!_stricmp(ctx.key, "Initial"))
{
ctx.ex->l.simple.initial = v;
found = true;
}
else if (!_stricmp(ctx.key, "... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x180017(%rip), %rsi # 0x2f9ac4
callq 0x16a10
cmpl $0x0, %eax
jne 0x179adb
movq (%rsp), %rax
movss 0xc(%rsp), %xmm0
movq 0x10(%rsp), %rcx
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
LabelSinglePropertyState<false>::Uint(Context<false>&, unsigned int) | BaseState<audit>* Uint(Context<audit>& ctx, unsigned v)
{
// skip "_label_"
ctx.key += 7;
ctx.key_length -= 7;
if (ctx.label_object_state.Uint(ctx, v) == nullptr)
return nullptr;
return ctx.previous_state;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x7, %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
subl $0x7, %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %rdi
addq $0x98, %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_example_json.h |
squaredloss::getLoss(shared_data*, float, float) | float getLoss(shared_data* sd, float prediction, float label)
{
if (prediction <= sd->max_label && prediction >= sd->min_label)
{
float example_loss = (prediction - label) * (prediction - label);
return example_loss;
}
else if (prediction < sd->min_label)
if (label == sd->min_label)
... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movss %xmm0, -0x1c(%rsp)
movss %xmm1, -0x20(%rsp)
movss -0x1c(%rsp), %xmm1
movq -0x18(%rsp), %rax
movss 0x6c(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x17faaf
movss -0x1c(%rsp), %xmm0
movq -0x18(%rsp), %rax
ucomiss 0x68(%rax), %xmm0
jb 0x17faaf
movss -0x1c(%rsp), %xmm0
subss -0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/loss_functions.cc |
logloss::wexpmx(float) | inline float wexpmx(float x)
{
/* This piece of code is approximating W(exp(x))-x.
* W is the Lambert W function: W(z)*exp(W(z))=z.
* The absolute error of this approximation is less than 9e-5.
* Faster/better approximations can be substituted here.
*/
double w = x >= 1. ? 0.86 * x + 0.01 ... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x173067(%rip), %xmm1 # 0x2f3ad8
ucomisd %xmm1, %xmm0
jb 0x180aa1
movss 0x3c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x17a337(%rip), %xmm1 # 0x2fadc0
mulsd %xmm1, %xmm0
movsd 0x178263(%rip), %xmm1 #... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/loss_functions.cc |
LEARNER::learner<nn, example>* calloc_or_throw<LEARNER::learner<nn, 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 0x1891ab
movq $0x0, 0x1e0(%rsp)
jmp 0x1892e1
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1892d1
leaq 0x16a6c4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
LEARNER::learner<confidence, example>& LEARNER::learner<confidence, example>::init_learner<LEARNER::learner<char, example>>(confidence*, LEARNER::learner<char, example>*, void (*)(confidence&, LEARNER::learner<char, example>&, example&), void (*)(confidence&, 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 0x18ac40
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x18ab10
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 |
print_result(int, float, v_array<char>, float, float) | void print_result(int f, float res, v_array<char> tag, float lb, float ub)
{
if (f >= 0)
{
char temp[30];
sprintf(temp, "%f", res);
std::stringstream ss;
ss << temp;
print_tag(ss, tag);
ss << ' ';
sprintf(temp, "%f", lb);
ss << temp;
ss << ' ';
sprintf(temp, "%f", ub);
ss... | subq $0x2b8, %rsp # imm = 0x2B8
leaq 0x2c0(%rsp), %rax
movq %rax, 0x68(%rsp)
movl %edi, 0x2b4(%rsp)
movss %xmm0, 0x2b0(%rsp)
movss %xmm1, 0x2ac(%rsp)
movss %xmm2, 0x2a8(%rsp)
cmpl $0x0, 0x2b4(%rsp)
jl 0x18b5d0
movss 0x2b0(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x16ff18(%rip), %rsi # 0x2fb260
leaq 0x280(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/bs.cc |
void predict_or_learn_adf<false, true>(cbify&, LEARNER::learner<char, std::vector<example*, std::allocator<example*>>>&, example&) | void predict_or_learn_adf(cbify& data, multi_learner& base, example& ec)
{
// Store the multiclass or cost-sensitive input label
MULTICLASS::label_t ld;
COST_SENSITIVE::label csl;
if (use_cs)
csl = ec.l.cs;
else
ld = ec.l.multi;
copy_example_to_adf(data, ec);
base.predict(data.adf_data.ecs);
a... | subq $0x418, %rsp # imm = 0x418
movq %rdi, 0x410(%rsp)
movq %rsi, 0x408(%rsp)
movq %rdx, 0x400(%rsp)
movq 0x400(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x3d8(%rsp)
movq 0x6830(%rax), %rcx
movq %rcx, 0x3e0(%rsp)
movq 0x6838(%rax), %rcx
movq %rcx, 0x3e8(%rsp)
movq 0x6840(%rax), %rax
movq %rax, 0x3f0(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cbify.cc |
cbify* calloc_or_throw<cbify>(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 0x19772b
movq $0x0, 0x1e0(%rsp)
jmp 0x197861
movq 0x1d8(%rsp), %rdi
movl $0xd0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x197851
leaq 0x15c144(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
int exploration::sample_after_normalizing<ACTION_SCORE::score_iterator>(unsigned long, ACTION_SCORE::score_iterator, ACTION_SCORE::score_iterator, unsigned int&, std::input_iterator_tag) | int sample_after_normalizing(uint64_t seed, It pdf_first, It pdf_last, uint32_t& chosen_index, std::input_iterator_tag /* pdf_category */)
{
if (pdf_first == pdf_last || pdf_last < pdf_first)
return E_EXPLORATION_BAD_RANGE;
// Create a discrete_distribution based on the returned weights. This class hand... | subq $0x88, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rax, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movq %rax, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
callq 0x198600
testb $0x1, %al
jne 0x1983dd
movq 0x18... | /LAIRLAB[P]vowpal_wabbit/explore/explore_internal.h |
v_array<ACTION_SCORE::action_score>::resize(unsigned long) | void resize(size_t length)
{
if ((size_t)(end_array - _begin) != length)
{
size_t old_len = _end - _begin;
T* temp = (T*)realloc(_begin, sizeof(T) * length);
if ((temp == nullptr) && ((sizeof(T) * length) > 0))
{
THROW("realloc of " << length << " failed in resize(). out of me... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
cmpq 0x1f8(%rsp), %rax
je 0x198c7c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rdx
subq %rdx, %rcx
sa... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/v_array.h |
LEARNER::learner<cbify, std::vector<example*, std::allocator<example*>>>* calloc_or_throw<LEARNER::learner<cbify, 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 0x198ecb
movq $0x0, 0x1e0(%rsp)
jmp 0x199001
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x198ff1
leaq 0x15a9a4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
copy_example_to_adf(warm_cb&, example&) | void copy_example_to_adf(warm_cb& data, example& ec)
{
const uint64_t ss = data.all->weights.stride_shift();
const uint64_t mask = data.all->weights.mask();
for (size_t a = 0; a < data.num_actions; ++a)
{
auto& eca = *data.ecs[a];
// clear label
auto& lab = eca.l.cb;
CB::cb_label.default_label(... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq 0x50(%rax), %rdi
addq $0x3590, %rdi # imm = 0x3590
callq 0x4c030
movl %eax, %eax
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq 0x50(%rax), %rdi
addq $0x3590, %rdi # imm = 0x3590
callq 0x72df0
movq %rax, 0x78(%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/warm_cb.cc |
void predict_or_learn_adf<false, true>(warm_cb&, LEARNER::learner<char, std::vector<example*, std::allocator<example*>>>&, example&) | void predict_or_learn_adf(warm_cb& data, multi_learner& base, example& ec)
{
// Corrupt labels (only corrupting multiclass labels as of now)
if (use_cs)
data.cs_label = ec.l.cs;
else
{
data.mc_label = ec.l.multi;
if (data.ws_iter < data.ws_period)
ec.l.multi.label = corrupt_action(data, data.mc_label.label... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x6828(%rcx), %rdx
movq %rdx, 0x148(%rax)
movq 0x6830(%rcx), %rdx
movq %rdx, 0x150(%rax)
movq 0x6838(%rcx), %rdx
movq %rdx, 0x158(%rax)
movq 0x6840(%rcx), %rcx
movq %rcx, 0x160(%rax)
movq 0x10(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/warm_cb.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 |
sort_data* calloc_or_throw<sort_data>(unsigned long) | T* calloc_or_throw(size_t nmemb)
{
if (nmemb == 0)
return nullptr;
void* data = calloc(nmemb, sizeof(T));
if (data == nullptr)
{
const char* msg = "internal error: memory allocation failed!\n";
// use low-level function since we're already out of memory.
fputs(msg, stderr);
THROW(msg);
}
... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
cmpq $0x0, 0x1d8(%rsp)
jne 0x1aa27b
movq $0x0, 0x1e0(%rsp)
jmp 0x1aa3b1
movq 0x1d8(%rsp), %rdi
movl $0x10, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1aa3a1
leaq 0x1495f4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
cycle_get(stagewise_poly const&, unsigned long) | inline bool cycle_get(const stagewise_poly &poly, uint64_t wid)
{
// note: intentionally leaving out ft_offset.
assert(wid % stride_shift(poly, 1) == 0);
if ((poly.depthsbits[wid_mask_un_shifted(poly, wid) * 2 + 1] & cycle_bit) > 0)
return true;
else
return false;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1aadd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
shlq %rcx
movzbl 0x1(%rax,%rcx), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jbe 0x1aa97a
movb $0x1, 0x27... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/stagewise_poly.cc |
void all_reduce<unsigned char, &reduce_min_max(unsigned char&, unsigned char const&)>(vw&, unsigned char*, unsigned long) | void all_reduce(vw& all, T* buffer, const size_t n)
{
switch (all.all_reduce_type)
{
case AllReduceType::Socket:
((AllReduceSockets*)all.all_reduce)->all_reduce<T, f>(buffer, n);
break;
case AllReduceType::Thread:
((AllReduceThreads*)all.all_reduce)->all_reduce<T, f>(buffer, n);
bre... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x1aaab0
jmp 0x1aaaa5
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x1aaaca
jmp 0x1aaae2
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/vw_allreduce.h |
void INTERACTIONS::inner_kernel<stagewise_poly, unsigned long, &synthetic_create_rec(stagewise_poly&, float, unsigned long), false, &void GD::dummy_func<stagewise_poly>(stagewise_poly&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_t... | 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 0x1ac6fd
jmp 0x1ac777
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
LEARNER::learner<stagewise_poly, example>* calloc_or_throw<LEARNER::learner<stagewise_poly, 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 0x1aef5b
movq $0x0, 0x1e0(%rsp)
jmp 0x1af091
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x1af081
leaq 0x144914(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.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.