name string | code string | asm string | file string |
|---|---|---|---|
bool VW::config::options_boost_po::add_if_t<std::vector<char, std::allocator<char>>>(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 0x129479(%rip), %rdi # 0x3914c0
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<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::shared_ptr<VW::config::base_option>, boost::p... | 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 0x269a80
movb %al, 0x2f(%rsp)
jmp 0x2681... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_boost_po::add_to_description<std::vector<char, std::allocator<char>>>(std::shared_ptr<VW::config::typed_option<std::vector<char, std::allocator<char>>>>, 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 0x268580
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<char, std::allocator<char>>, char>* VW::config::options_boost_po::get_base_boost_value<char>(std::shared_ptr<VW::config::typed_option<std::vector<char, std::allocator<char>>>>&) | 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 0x25a050
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x268580
movq %rax, %rdi
callq 0x2686c0
testb $0x1, %al
jne 0x26861a
jmp 0x268675
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<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::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 0x124d11(%rip), %rdi # 0x38e7d8
callq 0x579c0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_boost_po::add_to_description<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::shared_ptr<VW::config::typed_option<std::vector<std::__cxx11::basic_stri... | 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 0x269f10
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<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::get_base_boost_value<std::__cxx11::basic_string<char, std:... | 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 0x25ed00
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x269f10
movq %rax, %rdi
callq 0x26a050
testb $0x1, %al
jne 0x269faa
jmp 0x26a005
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_boost_po.h |
void VW::config::options_serializer_boost_po::add_impl<VW::config::typelist<>>(VW::config::base_option&) | void options_serializer_boost_po::add_impl<typelist<>>(base_option&)
{
THROW("That is an unsupported option type.");
} | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x16680
leaq 0x50(%rsp), %rdi
leaq 0x91926(%rip), %rsi # 0x2feac3
callq 0x16920
jmp 0x26d1a4
movb $0x1, 0xf(%rsp)
movl $0x38, %edi
callq 0x16450
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.cc |
bool VW::config::options_serializer_boost_po::serialize_if_t<unsigned int>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x124c9c(%rip), %rdi # 0x391f88
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26d382
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<int>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x124a0c(%rip), %rdi # 0x391ea8
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26d532
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<unsigned long>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x124914(%rip), %rdi # 0x391fb0
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26d732
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<float>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x1246ec(%rip), %rdi # 0x391f78
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26d922
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<double>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x1245a4(%rip), %rdi # 0x391fe0
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26dad2
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<char>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x124384(%rip), %rdi # 0x391fd0
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26dce2
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x11fe54(%rip), %rdi # 0x38de10
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26e052
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<std::vector<int, std::allocator<int>>>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x122994(%rip), %rdi # 0x390ce0
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26e3e2
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
void VW::config::options_serializer_boost_po::serialize<int>(VW::config::typed_option<std::vector<int, std::allocator<int>>>&) | void serialize(typed_option<std::vector<T>>& typed_option)
{
auto vec = typed_option.value();
if (vec.size() > 0)
{
for (auto const& value : vec)
{
m_output_stream << " --" << typed_option.m_name;
m_output_stream << " " << value;
}
}
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x26e6f0
leaq 0x50(%rsp), %rdi
callq 0x249280
cmpq $0x0, %rax
jbe 0x26e5e7
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2494d0
movq %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<std::vector<unsigned long, std::allocator<unsigned long>>>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x1226a4(%rip), %rdi # 0x390e50
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26e842
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
void VW::config::options_serializer_boost_po::serialize<unsigned long>(VW::config::typed_option<std::vector<unsigned long, std::allocator<unsigned long>>>&) | void serialize(typed_option<std::vector<T>>& typed_option)
{
auto vec = typed_option.value();
if (vec.size() > 0)
{
for (auto const& value : vec)
{
m_output_stream << " --" << typed_option.m_name;
m_output_stream << " " << value;
}
}
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x26eb60
leaq 0x50(%rsp), %rdi
callq 0x1321e0
cmpq $0x0, %rax
jbe 0x26ea48
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1320a0
movq %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
bool VW::config::options_serializer_boost_po::serialize_if_t<std::vector<float, std::allocator<float>>>(VW::config::base_option&) | bool serialize_if_t(base_option& base_option)
{
if (base_option.m_type_hash == typeid(T).hash_code())
{
auto typed = dynamic_cast<typed_option<T>&>(base_option);
serialize(typed);
return true;
}
return false;
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x1223ec(%rip), %rdi # 0x391008
callq 0x579c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x26ecb2
movq 0xd0(%rsp), %rdi
leaq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
void VW::config::options_serializer_boost_po::serialize<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(VW::config::typed_option<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... | void serialize(typed_option<std::vector<T>>& typed_option)
{
auto vec = typed_option.value();
if (vec.size() > 0)
{
for (auto const& value : vec)
{
m_output_stream << " --" << typed_option.m_name;
m_output_stream << " " << value;
}
}
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x26fb60
leaq 0x50(%rsp), %rdi
callq 0x1f7d0
cmpq $0x0, %rax
jbe 0x26fb45
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x25070
movq %rax, ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/options_serializer_boost_po.h |
resize_buf_if_needed(char*&, unsigned long&, unsigned long) | bool resize_buf_if_needed(char*& __dest, size_t& __dest_size, const size_t __n)
{
char* new_dest;
if (__dest_size < __n)
{
if ((new_dest = (char*)realloc(__dest, __n)) == NULL)
THROW("Can't realloc enough memory.")
else
{
__dest = new_dest;
__dest_size = __n;
return true;
}... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1e8(%rsp)
movq %rsi, 0x1e0(%rsp)
movq %rdx, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
cmpq 0x1d8(%rsp), %rax
jae 0x26fd9c
movq 0x1e8(%rsp), %rax
movq (%rax), %rdi
movq 0x1d8(%rsp), %rsi
callq 0x17040
movq %rax, 0x1d0(%rsp)
cmpq $0x0, %rax
jne 0x26fd6c
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
safe_sprintf_s(char*&, unsigned long&, char const*, ...) | int32_t safe_sprintf_s(char*& buf, size_t& buf_size, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
int32_t len = vsprintf_s(buf, buf_size, fmt, args);
va_end(args);
if (len < 0)
THROW("Encoding error.");
if (resize_buf_if_needed(buf, buf_size, len + 1))
{
va_start(args, fmt);
vspr... | subq $0x2c8, %rsp # imm = 0x2C8
testb %al, %al
je 0x26fdff
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rc... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
save_load_header(vw&, io_buf&, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, VW::config::options_i&) | void save_load_header(
vw& all, io_buf& model_file, bool read, bool text, std::string& file_options, VW::config::options_i& options)
{
char* buff2 = (char*)malloc(default_buf_size);
size_t buf2_size = default_buf_size;
try
{
if (model_file.files.size() > 0)
{
size_t bytes_read_write = 0;
... | subq $0x1238, %rsp # imm = 0x1238
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x1230(%rsp)
movq %rsi, 0x1228(%rsp)
andb $0x1, %cl
movb %cl, 0x1227(%rsp)
andb $0x1, %al
movb %al, 0x1226(%rsp)
movq %r8, 0x1218(%rsp)
movq %r9, 0x1210(%rsp)
movl $0x200, %edi # imm = 0x200
callq 0x16cf0
movq %rax, 0x1208(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
dump_regressor(vw&, io_buf&, bool) | void dump_regressor(vw& all, io_buf& buf, bool as_text)
{
std::string unused;
save_load_header(all, buf, false, as_text, unused, *all.options);
if (all.l != nullptr)
all.l->save_load(buf, false, as_text);
buf.flush(); // close_file() should do this for me ...
buf.close_file();
} | subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x16d80
movq 0x8(%rsp), %r8
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x278(%rdi), %r9
movzbl 0x47(%rsp), %ecx
andl $0x1, %ecx
xorl %edx, %edx
callq 0x27... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
dump_regressor(vw&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | void dump_regressor(vw& all, string reg_name, bool as_text)
{
if (reg_name == string(""))
return;
string start_name = reg_name + string(".writing");
io_buf io_temp;
io_temp.open_file(start_name.c_str(), all.stdin_off, io_buf::WRITE);
dump_regressor(all, io_temp, as_text);
remove(reg_name.c_str());
... | subq $0x338, %rsp # imm = 0x338
movq %rsi, 0x38(%rsp)
movb %dl, %al
movq %rdi, 0x330(%rsp)
movq %rsi, 0x328(%rsp)
andb $0x1, %al
movb %al, 0x327(%rsp)
leaq 0x2ff(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x17200
movq 0x40(%rsp), %rdx
leaq 0x8603a(%rip), %rsi # 0x2f935f
leaq 0x300(%rsp), %rdi
callq 0x16d50
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
finalize_regressor(vw&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void finalize_regressor(vw& all, string reg_name)
{
if (!all.early_terminate)
{
if (all.per_feature_regularizer_output.length() > 0)
dump_regressor(all, all.per_feature_regularizer_output, false);
else
dump_regressor(all, reg_name, false);
if (all.per_feature_regularizer_text.length() > 0)
... | subq $0x118, %rsp # imm = 0x118
movq %rsi, 0x50(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rax
testb $0x1, 0x3458(%rax)
jne 0x273a6c
movq 0x110(%rsp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
callq 0x16ed0
cmpq $0x0, %rax
jbe 0x27388c
movq 0x110(%rsp), %rsi
movq %rsi, 0x40(... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
read_regressor_file(vw&, 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>>>>, io_buf&) | void read_regressor_file(vw& all, std::vector<std::string> all_intial, io_buf& io_temp)
{
if (all_intial.size() > 0)
{
io_temp.open_file(all_intial[0].c_str(), all.stdin_off, io_buf::READ);
if (!all.quiet)
{
// all.trace_message << "initial_regressor = " << regs[0] << endl;
if (all_intial.si... | subq $0x38, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
callq 0x1f7d0
cmpq $0x0, %rax
jbe 0x273b7d
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2b1e0
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
parse_mask_regressor_args(vw&, std::__cxx11::basic_string<char, std::char_traits<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>>>>) | void parse_mask_regressor_args(vw& all, std::string feature_mask, std::vector<std::string> initial_regressors)
{
// TODO does this extra check need to be used? I think it is duplicated but there may be some logic I am missing.
std::string file_options;
if (!feature_mask.empty())
{
if (initial_regressors.siz... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq %rdx, 0x1a0(%rsp)
leaq 0x180(%rsp), %rdi
callq 0x16d80
movq 0x10(%rsp), %rdi
callq 0x17090
testb $0x1, %al
jne 0x273dc5
movq 0x8(%rsp), %rdi
callq 0x1f7d0
cmpq $0x0, %rax
jbe 0x273c1b... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
void initialize_regressor<sparse_parameters>(vw&, sparse_parameters&) | void initialize_regressor(vw& all, T& weights)
{
// Regressor is already initialized.
if (weights.not_null())
return;
size_t length = ((size_t)1) << all.num_bits;
try
{
uint32_t ss = weights.stride_shift();
weights.~T(); // dealloc so that we can realloc, now with a known size
new (&weights)... | subq $0x3c8, %rsp # imm = 0x3C8
movq %rdi, 0x3c0(%rsp)
movq %rsi, 0x3b8(%rsp)
movq 0x3b8(%rsp), %rdi
callq 0x15cfe0
testb $0x1, %al
jne 0x273f3a
jmp 0x273f3f
jmp 0x27435a
movq 0x3c0(%rsp), %rax
movb 0x50(%rax), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x3b0(%rsp)
movq 0x3b8(%rsp), %rdi
callq 0x53350
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
void initialize_regressor<dense_parameters>(vw&, dense_parameters&) | void initialize_regressor(vw& all, T& weights)
{
// Regressor is already initialized.
if (weights.not_null())
return;
size_t length = ((size_t)1) << all.num_bits;
try
{
uint32_t ss = weights.stride_shift();
weights.~T(); // dealloc so that we can realloc, now with a known size
new (&weights)... | subq $0x3c8, %rsp # imm = 0x3C8
movq %rdi, 0x3c0(%rsp)
movq %rsi, 0x3b8(%rsp)
movq 0x3b8(%rsp), %rdi
callq 0x15d020
testb $0x1, %al
jne 0x2743aa
jmp 0x2743af
jmp 0x2747ca
movq 0x3c0(%rsp), %rax
movb 0x50(%rax), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x3b0(%rsp)
movq 0x3b8(%rsp), %rdi
callq 0x53360
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
io_buf::hash() | uint32_t hash()
{
if (!_verify_hash)
THROW("HASH WAS NOT CALCULATED");
return _hash;
} | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
jne 0x274b59
leaq 0x48(%rsp), %rdi
callq 0x16680
leaq 0x58(%rsp), %rdi
leaq 0x8bbd7(%rip), %rsi # 0x300673
callq 0x16920
jmp 0x274aa3
movb $0x1, 0x17(%rsp)
movl $0x38, %edi
callq 0x164... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/io_buf.h |
bin_read(io_buf&, char*, unsigned long, char const*) | inline size_t bin_read(io_buf& i, char* data, size_t len, const char* read_message)
{
uint32_t obj_len;
size_t ret = i.bin_read_fixed((char*)&obj_len, sizeof(obj_len), "");
if (obj_len > len || ret < sizeof(uint32_t))
THROW("bad model format!");
ret += i.bin_read_fixed(data, obj_len, read_message);
retu... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movq %rcx, 0x1d8(%rsp)
movq 0x1f0(%rsp), %rdi
leaq 0x1d4(%rsp), %rsi
movl $0x4, %edx
leaq 0x8479c(%rip), %rcx # 0x2f935f
callq 0x745f0
movq %rax, 0x1c8(%rsp)
movl 0x1d4(%rsp), %eax
cmpq 0x1e0(%rsp), %rax
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/io_buf.h |
polar_normal_weights_wrapper<sparse_parameters>::func(float&, unsigned long) | static void func(weight& w, uint64_t index)
{
static float x1 = 0.0;
static float x2 = 0.0;
static float temp = 0.0;
do
{
x1 = 2.0f * merand48(index) - 1.0f;
x2 = 2.0f * merand48(index) - 1.0f;
temp = x1 * x1 + x2 * x2;
} while ((temp >= 1.0) || (temp == 0.0));
temp = sqr... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x278020
addss %xmm0, %xmm0
movss 0x818ac(%rip), %xmm1 # 0x2f6bb0
addss %xmm1, %xmm0
movss %xmm0, 0x11e250(%rip) # 0x393560
leaq 0x8(%rsp), %rdi
callq 0x278020
addss %xmm0, %xmm0
movss 0x8188a(%rip), %xmm1 # 0x2f6bb0
addss %x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
double calculate_sd<sparse_parameters>(vw&, sparse_parameters&) | double calculate_sd(vw& /* all */, T& weights)
{
static int my_size = 0;
for_each(weights.begin(), weights.end(), [](float /* v */) { my_size += 1; });
double sum = accumulate(weights.begin(), weights.end(), 0.0);
double mean = sum / my_size;
vector<double> diff(my_size);
transform(weights.begin(), weights.... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq 0x198(%rsp), %rdi
callq 0x6edc0
movl %edx, 0x180(%rsp)
movq %rax, 0x178(%rsp)
movl 0x180(%rsp), %eax
movl %eax, 0x190(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x188(%rsp)
movq 0x198(%rsp), %rdi
callq 0x6ee10
movl %edx, 0x160(%r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
polar_normal_weights_wrapper<dense_parameters>::func(float&, unsigned long) | static void func(weight& w, uint64_t index)
{
static float x1 = 0.0;
static float x2 = 0.0;
static float temp = 0.0;
do
{
x1 = 2.0f * merand48(index) - 1.0f;
x2 = 2.0f * merand48(index) - 1.0f;
temp = x1 * x1 + x2 * x2;
} while ((temp >= 1.0) || (temp == 0.0));
temp = sqr... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x278020
addss %xmm0, %xmm0
movss 0x808bc(%rip), %xmm1 # 0x2f6bb0
addss %xmm1, %xmm0
movss %xmm0, 0x11d284(%rip) # 0x393584
leaq 0x8(%rsp), %rdi
callq 0x278020
addss %xmm0, %xmm0
movss 0x8089a(%rip), %xmm1 # 0x2f6bb0
addss %x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
double calculate_sd<dense_parameters>(vw&, dense_parameters&) | double calculate_sd(vw& /* all */, T& weights)
{
static int my_size = 0;
for_each(weights.begin(), weights.end(), [](float /* v */) { my_size += 1; });
double sum = accumulate(weights.begin(), weights.end(), 0.0);
double mean = sum / my_size;
vector<double> diff(my_size);
transform(weights.begin(), weights.... | subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
movq 0x168(%rsp), %rsi
leaq 0x150(%rsp), %rdi
callq 0x6ef70
movq 0x168(%rsp), %rsi
leaq 0x138(%rsp), %rdi
callq 0x6efc0
movq 0x148(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movups 0x138(%rsp), %xmm0
movups %xmm0, 0x18(%rax)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_regressor.cc |
hashstring(substring, unsigned long) | uint64_t hashstring(substring s, uint64_t h)
{
// trim leading whitespace but not UTF-8
for (; s.begin < s.end && *(s.begin) <= 0x20 && (int)*(s.begin) >= 0; s.begin++)
;
// trim trailing white space but not UTF-8
for (; s.end > s.begin && *(s.end - 1) <= 0x20 && (int)*(s.end - 1) >= 0; s.end--)
;
si... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0x7(%rsp)
jae 0x276aaa
movq 0x20(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, 0x7(%rsp)
jg 0x276aaa
movq 0x20(%rsp), %rax
movsbl (%rax), ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_primitives.cc |
getHasher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | hash_func_t getHasher(const std::string& s)
{
if (s == "strings")
return hashstring;
else if (s == "all")
return hashall;
else
THROW("Unknown hash function: " << s);
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rdi
leaq 0x7d7ee(%rip), %rsi # 0x2f440c
callq 0x474a0
testb $0x1, %al
jne 0x276c29
jmp 0x276c3d
leaq -0x1d0(%rip), %rax # 0x276a60
movq %rax, 0x1e0(%rsp)
jmp 0x276d5b
movq 0x1d8(%rsp), %rdi
leaq 0x7d80e(%rip), %rsi # 0x2f4... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_primitives.cc |
operator<<(std::ostream&, v_array<substring> const&) | std::ostream& operator<<(std::ostream& os, const v_array<substring>& ss)
{
substring* it = ss.cbegin();
if (it == ss.cend())
{
return os;
}
os << *it;
for (it++; it != ss.cend(); it++)
{
os << ",";
os << *it;
}
return os;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x276f80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x276f90
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x276e8a
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x27... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_primitives.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 |
unique_features(features&, int) | void unique_features(features& fs, int max)
{
if (fs.indicies.empty())
return;
features::features_value_index_audit_range range = fs.values_indices_audit();
features::iterator_all last_index = range.begin();
features::iterator_all end = max > 0 ? range.begin() + min(fs.size(), (size_t)max) : range.end();
... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movq 0xb0(%rsp), %rdi
addq $0x20, %rdi
callq 0x277270
testb $0x1, %al
jne 0x276fcd
jmp 0x276fd2
jmp 0x2771b6
movq 0xb0(%rsp), %rdi
callq 0x6e000
movq %rax, 0xa0(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x6e030
cmpl $0x0, 0xac(%rsp)
jle 0x277049... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/unique_sort.cc |
read_cached_tag(io_buf&, example*) | size_t read_cached_tag(io_buf& cache, example* ae)
{
char* c;
size_t tag_size;
if (cache.buf_read(c, sizeof(tag_size)) < sizeof(tag_size))
return 0;
tag_size = *(size_t*)c;
c += sizeof(tag_size);
cache.set(c);
if (cache.buf_read(c, tag_size) < tag_size)
return 0;
ae->tag.clear();
push_many(ae... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x2d950
cmpq $0x8, %rax
jae 0x277436
movq $0x0, 0x20(%rsp)
jmp 0x2774bb
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cache.cc |
read_cached_features(vw*, v_array<example*>&) | int read_cached_features(vw* all, v_array<example*>& examples)
{
example* ae = examples[0];
ae->sorted = all->p->sorted_cache;
io_buf* input = all->p->input;
size_t total = all->p->lp.read_cached_label(all->sd, &ae->l, *input);
if (total == 0)
return 0;
if (read_cached_tag(*input, ae) == 0)
return ... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x117a50
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq 0x8(%rax), %rax
movb 0x21a(%rax), %cl
movq 0x78(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x68ca(%rax)
movq 0x88(%rsp), %rax
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cache.cc |
output_features(io_buf&, unsigned char, features&, unsigned long) | void output_features(io_buf& cache, unsigned char index, features& fs, uint64_t mask)
{
char* c;
size_t storage = fs.size() * int_size;
for (feature_value f : fs.values)
if (f != 1. && f != -1.)
storage += sizeof(feature_value);
cache.buf_write(c, sizeof(index) + storage + sizeof(size_t));
*reinter... | subq $0xb8, %rsp
movb %sil, %al
movq %rdi, 0xb0(%rsp)
movb %al, 0xaf(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x47ac0
imulq $0xb, %rax, %rax
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x72c60
movq (%rax), %rax
movq %rax, 0x78(%rsp)
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cache.cc |
run_len_encode(char*, unsigned long) | inline char* run_len_encode(char* p, uint64_t i)
{
// store an int 7 bits at a time.
while (i >= 128)
{
*(p++) = (i & 127) | 128;
i = i >> 7;
}
*(p++) = (i & 127);
return p;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x80, -0x10(%rsp)
jb 0x277ff9
movq -0x10(%rsp), %rax
andq $0x7f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x7, %rax
movq %rax, -0x10(%rsp)
jmp 0x277fba
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cache.cc |
bits_to_float(unsigned int) | static inline float bits_to_float(uint32_t a)
{
union {
float f;
uint32_t i;
} x;
x.i = a;
return x.f;
} | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x8(%rsp)
movss -0x8(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/floatbits.h |
bufread_simple_label(shared_data*, label_data*, char*) | char* bufread_simple_label(shared_data* sd, label_data* ld, char* c)
{
memcpy(&ld->label, c, sizeof(ld->label));
// cout << ld->label << " " << sd->is_more_than_two_labels_observed << " " << sd->first_observed_label << endl;
c += sizeof(ld->label);
memcpy(&ld->weight, c, sizeof(ld->weight));
c += sizeof(ld-... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
addq $0x4, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq (%rsp), %rax
addq $0x4, %rax
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/simple_label.cc |
read_cached_simple_label(shared_data*, void*, io_buf&) | size_t read_cached_simple_label(shared_data* sd, void* v, io_buf& cache)
{
label_data* ld = (label_data*)v;
char* c;
size_t total = sizeof(ld->label) + sizeof(ld->weight) + sizeof(ld->initial);
if (cache.buf_read(c, total) < total)
return 0;
bufread_simple_label(sd, ld, c);
return total;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0xc, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x2d950
cmpq (%rsp), %rax
jae 0x278189
movq $0x0, 0x30(%rsp)
jmp 0x2781a6
movq 0x28(%rsp), %rdi
movq 0x10(%r... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/simple_label.cc |
bufcache_simple_label(label_data*, char*) | char* bufcache_simple_label(label_data* ld, char* c)
{
memcpy(c, &ld->label, sizeof(ld->label));
c += sizeof(ld->label);
memcpy(c, &ld->weight, sizeof(ld->weight));
c += sizeof(ld->weight);
memcpy(c, &ld->initial, sizeof(ld->initial));
c += sizeof(ld->initial);
return c;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/simple_label.cc |
parse_simple_label(parser*, shared_data*, void*, v_array<substring>&) | void parse_simple_label(parser*, shared_data* sd, void* v, v_array<substring>& words)
{
label_data* ld = (label_data*)v;
switch (words.size())
{
case 0:
break;
case 1:
ld->label = float_of_substring(words[0]);
break;
case 2:
ld->label = float_of_substring(words[0]);
ld->... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2383b0
movq %rax, %rcx
movq %rcx, 0x10(%rsp)
subq $0x3, %rax
ja 0x2784ff
movq 0x10(%rsp), %rax
leaq 0x8843a(%rip), %rcx # 0x30079c
movslq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/simple_label.cc |
output_and_account_example(vw&, example&) | void output_and_account_example(vw& all, 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.print(all.raw_prediction, ec... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x7c(%rsp)
movl 0x6830(%rax), %eax
movl %eax, 0x84(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rdi
movq 0x88(%rsp), %rax
movb 0x68c8(%rax), %dl
movss 0x7c(%rsp), %xmm0
movss 0x7afa1(%rip), %xmm1 # 0x2f... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/simple_label.cc |
summarize_holdout_set(vw&, unsigned long&) | bool summarize_holdout_set(vw& all, size_t& no_win_counter)
{
float thisLoss = (all.sd->weighted_holdout_examples_since_last_pass > 0)
? (float)(all.sd->holdout_sum_loss_since_last_pass / all.sd->weighted_holdout_examples_since_last_pass)
: FLT_MAX * 0.5f;
if (all.all_reduce != nullptr)
thisLoss = a... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsd 0xa0(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x278a13
movq 0x18(%rsp), %rax
movq (%rax), %rax
movsd 0xa8(%rax), %xmm0
movq 0x18(%rsp), %rax
movq (%rax), %rax
divsd 0xa0(%rax), %xmm0
cvtsd2ss %xmm0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/simple_label.cc |
float_of_substring(substring) | inline float float_of_substring(substring s)
{
char* endptr = s.end;
float f = parseFloat(s.begin, &endptr);
if ((endptr == s.begin && s.begin != s.end) || nanpattern(f))
{
std::cout << "warning: " << std::string(s.begin, s.end - s.begin).c_str()
<< " is not a good float, replacing with 0" << ... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x278cd0
movss %xmm0, 0x6c(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x78(%rsp), %rax
jne 0x278ba5
movq 0x78(%rsp), %rax
cmpq 0x80(%rsp), %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_primitives.h |
parseFloat(char*, char**, char*) | inline float parseFloat(char* p, char** end, char* endLine = nullptr)
{
char* start = p;
bool endLine_is_null = endLine == nullptr;
if (!*p)
{
*end = p;
return 0;
}
int s = 1;
while ((*p == ' ') && (endLine_is_null || p < endLine)) p++;
if (*p == '-')
{
s = -1;
p++;
}
float acc ... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x38(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x278d21
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
xorps %xmm0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/parse_primitives.h |
MULTICLASS::read_cached_label(shared_data*, void*, io_buf&) | size_t read_cached_label(shared_data*, void* v, io_buf& cache)
{
label_t* ld = (label_t*)v;
char* c;
size_t total = sizeof(ld->label) + sizeof(ld->weight);
if (cache.buf_read(c, total) < total)
return 0;
bufread_label(ld, c);
return total;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x8, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x2d950
cmpq (%rsp), %rax
jae 0x279159
movq $0x0, 0x30(%rsp)
jmp 0x279171
movq 0x10(%rsp), %rdi
movq 0x8(%rs... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/multiclass.cc |
MULTICLASS::parse_label(parser*, shared_data*, void*, v_array<substring>&) | void parse_label(parser*, shared_data* sd, void* v, v_array<substring>& words)
{
label_t* ld = (label_t*)v;
switch (words.size())
{
case 0:
break;
case 1:
ld->label = sd->ldict ? (uint32_t)sd->ldict->get(words[0]) : int_of_substring(words[0]);
ld->weight = 1.0;
break;
case 2:
... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0x230(%rsp)
movq 0x238(%rsp), %rdi
callq 0x2383b0
movq %rax, %rcx
movq %rcx, 0x38(%rsp)
testq %rax, %rax
je 0x279334
jmp 0x279313
movq 0x38(%rsp), %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/multiclass.cc |
MULTICLASS::print_label_pred(vw&, example&, unsigned int) | void print_label_pred(vw& all, example& ec, uint32_t prediction)
{
substring ss_label = all.sd->ldict->get(ec.l.multi.label);
substring ss_pred = all.sd->ldict->get(prediction);
all.sd->print_update(all.holdout_set_off, all.current_pass,
!ss_label.begin ? "unknown" : string(ss_label.begin, ss_label.end - ss... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movl %edx, 0xe4(%rsp)
movq 0xf0(%rsp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rdi
movq 0xe8(%rsp), %rax
movl 0x6828(%rax), %esi
callq 0x27a5a0
movq %rax, 0xd0(%rsp)
movq %rdx, 0xd8(%rsp)
movq 0xf0(%rsp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rdi
movl 0xe... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/multiclass.cc |
MULTICLASS::print_probability(vw&, example&, unsigned int) | void print_probability(vw& all, example& ec, uint32_t prediction)
{
char temp_str[10];
sprintf_s(temp_str, 10, "%d(%2.0f%%)", prediction, 100 * ec.pred.scalars[prediction - 1]);
char label_str[512];
sprintf_s(label_str, 512, "%u", ec.l.multi.label);
all.sd->print_update(
all.holdout_set_off, all.curre... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movl %edx, 0x2b4(%rsp)
movl 0x2b4(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x2b8(%rsp), %rdi
addq $0x6850, %rdi # imm = 0x6850
decl %eax
movl %eax, %esi
callq 0x77640
movl 0x14(%rsp), %ecx
movss (%rax), %xmm0
movss 0x829b7(... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/multiclass.cc |
MULTICLASS::finish_example(vw&, example&, bool) | void finish_example(vw& all, example& ec, bool update_loss)
{
float loss = 0;
if (ec.l.multi.label != (uint32_t)ec.pred.multiclass && ec.l.multi.label != (uint32_t)-1)
loss = ec.weight;
all.sd->update(ec.test_only, update_loss && (ec.l.multi.label != (uint32_t)-1), loss, ec.weight, ec.num_features);
for (... | subq $0x128, %rsp # imm = 0x128
movb %dl, %al
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
andb $0x1, %al
movb %al, 0x117(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x110(%rsp)
movq 0x118(%rsp), %rax
movl 0x6828(%rax), %eax
movq 0x118(%rsp), %rcx
cmpl 0x6850(%rcx), %eax
je 0x279f46
movq 0x118(%rsp), %rax
cmpl $-... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/multiclass.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 |
float_to_bits(float) | static inline uint32_t float_to_bits(float a)
{
union {
float f;
uint32_t i;
} x;
x.f = a;
return x.i;
} | movss %xmm0, -0x4(%rsp)
movss -0x4(%rsp), %xmm0
movss %xmm0, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopw (%rax,%rax)
| /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/floatbits.h |
CSOAA::process_labels(CSOAA::ldf&, std::vector<example*, std::allocator<example*>> const&) | multi_ex process_labels(ldf& data, const multi_ex& ec_seq_all)
{
example* ec = ec_seq_all[0];
// check the first element, if it's not a label, return
if (!ec_is_label_definition(*ec))
return ec_seq_all;
// process the first element as a label
process_label(data, ec);
multi_ex ret;
size_t i = 1;
/... | subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a0240
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x29ace0
testb $0x1, %al
jne 0x29d628
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/csoaa.cc |
void CSOAA::predict_or_learn<true>(CSOAA::csoaa&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(csoaa& c, single_learner& base, example& ec)
{
// cerr << "------------- passthrough" << endl;
COST_SENSITIVE::label ld = ec.l.cs;
uint32_t prediction = 1;
float score = FLT_MAX;
size_t pt_start = ec.passthrough ? ec.passthrough->size() : 0;
ec.l.simple = {0., 0., 0.};
if (ld.costs.s... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x80(%rsp)
movq 0x6830(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq 0x6838(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq 0x6840(%rax), %rax
movq %rax, 0x98(%rsp)
movl $0x1, 0x7c(%rsp)
movss 0x5... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/csoaa.cc |
void GD::foreach_feature<example&, unsigned long, &CSOAA::subtract_feature(example&, float, unsigned long)>(vw&, example&, example&) | 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 0x29ffc6
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 |
CSOAA::process_label(CSOAA::ldf&, example*) | void inline process_label(ldf& data, example* ec)
{
auto new_fs = ec->feature_space[ec->indices[0]];
auto& costs = ec->l.cs.costs;
for (size_t j = 0; j < costs.size(); j++)
{
const auto lab = (size_t)costs[j].x;
LabelDict::set_label_features(data.label_features, lab, new_fs);
}
} | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1448b0
movq 0x10(%rsp), %rsi
movzbl (%rax), %eax
imulq $0x68, %rax, %rax
addq %rax, %rsi
leaq 0x30(%rsp), %rdi
movl $0x68, %edx
callq 0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/csoaa.cc |
void CSOAA::do_actual_learning<true>(CSOAA::ldf&, LEARNER::learner<char, example>&, std::vector<example*, std::allocator<example*>>&) | void do_actual_learning(ldf& data, single_learner& base, multi_ex& ec_seq_all)
{
if (ec_seq_all.size() == 0)
return; // nothing to do
data.ft_offset = ec_seq_all[0]->ft_offset;
// handle label definitions
auto ec_seq = process_labels(data, ec_seq_all);
if (ec_seq.size() == 0)
return; // nothing mo... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2e0(%rsp)
movq %rsi, 0x2d8(%rsp)
movq %rdx, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rdi
callq 0x117320
cmpq $0x0, %rax
jne 0x2a0557
jmp 0x2a0dac
movq 0x2d0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x192c60
movq (%rax), %rax
movq 0x6820(%rax), %rcx
movq 0x2e0(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/csoaa.cc |
CSOAA::csoaa* calloc_or_throw<CSOAA::csoaa>(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 0x2a181b
movq $0x0, 0x1e0(%rsp)
jmp 0x2a1951
movq 0x1d8(%rsp), %rdi
movl $0x10, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2a1941
leaq 0x52054(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
LEARNER::learner<CSOAA::csoaa, example>* calloc_or_throw<LEARNER::learner<CSOAA::csoaa, 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 0x2a1e5b
movq $0x0, 0x1e0(%rsp)
jmp 0x2a1f91
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2a1f81
leaq 0x51a14(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
void CSOAA::inner_loop<false>(LEARNER::learner<char, example>&, example&, unsigned int, float, unsigned int&, float&, float&) | inline void inner_loop(single_learner& base, example& ec, uint32_t i, float cost, uint32_t& prediction, float& score,
float& partial_prediction)
{
if (is_learn)
{
ec.weight = (cost == FLT_MAX) ? 0.f : 1.f;
ec.l.simple.label = cost;
base.learn(ec, i - 1);
}
else
base.predict(ec, i - 1);
pa... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movss %xmm0, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2aeb0
movq 0x28(%rsp), %rax
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/csoaa.cc |
void CB_ALGS::predict_or_learn<false>(CB_ALGS::cb&, LEARNER::learner<char, example>&, example&) | void predict_or_learn(cb& data, single_learner& base, example& ec)
{
CB::label ld = ec.l.cb;
cb_to_cs& c = data.cbcs;
c.known_cost = get_observed_cost(ld);
if (c.known_cost != nullptr && (c.known_cost->action < 1 || c.known_cost->action > c.num_actions))
cerr << "invalid action: " << c.known_cost->action <<... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x6830(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x6838(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x6840(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/cb_algs.cc |
void GEN_CS::gen_cs_example_dm<true>(GEN_CS::cb_to_cs&, example&, COST_SENSITIVE::label&) | void gen_cs_example_dm(cb_to_cs& c, example& ec, COST_SENSITIVE::label& cs_ld)
{ // this implements the direct estimation method, where costs are directly specified by the learned regressor.
CB::label ld = ec.l.cb;
float min = FLT_MAX;
uint32_t argmin = 1;
// generate cost sensitive example
cs_ld.costs.clea... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq 0x6828(%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x6830(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x6838(%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x6840(%rax), %rax
movq %rax, 0x78(%rsp)
movss 0x43811(%rip), %xmm0 #... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gen_cs_example.h |
void GEN_CS::gen_cs_example_dr<true>(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 0x2b043f
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<true>(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 |
CB_ALGS::cb* calloc_or_throw<CB_ALGS::cb>(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 0x2b073b
movq $0x0, 0x1e0(%rsp)
jmp 0x2b0871
movq 0x1d8(%rsp), %rdi
movl $0x78, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2b0861
leaq 0x43134(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
LEARNER::learner<CB_ALGS::cb, example>& LEARNER::learner<CB_ALGS::cb, example>::init_learner<LEARNER::learner<char, example>>(CB_ALGS::cb*, LEARNER::learner<char, example>*, void (*)(CB_ALGS::cb&, LEARNER::learner<char, example>&, example&), void (*)(CB_ALGS::cb&, LEARNER::learner<char, example>&, example&), unsigned l... | 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 0x2b0d40
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x2b0c10
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 |
LEARNER::learner<CB_ALGS::cb, example>* calloc_or_throw<LEARNER::learner<CB_ALGS::cb, 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 0x2b0d7b
movq $0x0, 0x1e0(%rsp)
jmp 0x2b0eb1
movq 0x1d8(%rsp), %rdi
movl $0xf0, %esi
callq 0x16600
movq %rax, 0x1d0(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x2b0ea1
leaq 0x42af4(%rip), %rax # 0x2f389f
movq %rax, 0x1c8(%rsp)
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/memory.h |
Search::clear_memo_foreach_action(Search::search_private&) | void clear_memo_foreach_action(search_private& priv)
{
for (size_t i = 0; i < priv.memo_foreach_action.size(); i++)
if (priv.memo_foreach_action[i])
{
priv.memo_foreach_action[i]->delete_v();
delete priv.memo_foreach_action[i];
}
priv.memo_foreach_action.clear();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x668, %rdi # imm = 0x668
callq 0x2c3580
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2b10d9
movq 0x20(%rsp), %rdi
addq $0x668, %rdi # imm = 0x668
mov... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::random_policy(Search::search_private&, bool, bool, bool) | int random_policy(search_private& priv, bool allow_current, bool allow_optimal, bool advance_prng = true)
{
if (priv.beta >= 1)
{
if (allow_current)
return (int)priv.current_policy;
if (priv.current_policy > 0)
return (((int)priv.current_policy) - 1);
if (allow_optimal)
return -1;
... | subq $0x38, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x28(%rsp)
andb $0x1, %dl
movb %dl, 0x27(%rsp)
andb $0x1, %cl
movb %cl, 0x26(%rsp)
andb $0x1, %al
movb %al, 0x25(%rsp)
movq 0x28(%rsp), %rax
movss 0x290(%rax), %xmm0
movss 0x4259b(%rip), %xmm1 # 0x2f36c4
ucomiss %xmm1, %xmm0
jb 0x2b11bc
testb $0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::select_learner(Search::search_private&, int, unsigned long, bool, bool) | int select_learner(search_private& priv, int policy, size_t learner_id, bool is_training, bool is_local)
{
if (policy < 0)
return policy; // optimal policy
else
{
if (priv.xv)
{
learner_id *= 3;
if (!is_local)
learner_id += 1 + (size_t)(is_training ^ (priv.all->sd->example_number ... | movb %r8b, %al
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
andb $0x1, %cl
movb %cl, -0x21(%rsp)
andb $0x1, %al
movb %al, -0x22(%rsp)
cmpl $0x0, -0x14(%rsp)
jge 0x2b145f
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x2b14dc
movq -0x10(%rsp), %rax
testb $0x1, 0x2a4(%rax)
je 0x2b14bc
imulq $0x... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::should_print_update(vw&, bool) | bool should_print_update(vw& all, bool hit_new_pass = false)
{
// uncomment to print out final loss after all examples processed
// commented for now so that outputs matches make test
if (PRINT_UPDATE_EVERY_EXAMPLE)
return true;
if (PRINT_UPDATE_EVERY_PASS && hit_new_pass)
return true;
return (all.sd... | subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x4c940
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss 0x50(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, 0xe(%rsp)
jb 0x2b1551
movq 0x10(%rsp), %rcx
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::must_run_test(vw&, std::vector<example*, std::allocator<example*>>&, bool) | bool must_run_test(vw& all, multi_ex& ec, bool is_test_ex)
{
return (all.final_prediction_sink.size() > 0) || // if we have to produce output, we need to run this
might_print_update(all) || // if we have to print and update to stderr
(all.raw_prediction > 0) || // we ... | subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
addq $0x3510, %rdi # imm = 0x3510
callq 0x2e240
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, 0x6(%rsp)
ja 0x2b16e0
movq 0x10(%rsp), %rdi
callq 0x2b1560
movb %al, %cl
m... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::to_short_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, char*) | void to_short_string(string in, size_t max_len, char* out)
{
for (size_t i = 0; i < max_len; i++)
out[i] = ((i >= in.length()) || (in[i] == '\n') || (in[i] == '\t')) ? ' ' : in[i];
if (in.length() > max_len)
{
out[max_len - 2] = '.';
out[max_len - 1] = '.';
}
out[max_len] = 0;
} | subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2b17f1
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x16ed0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::number_to_natural(unsigned long, char*) | void number_to_natural(size_t big, char* c)
{
if (big > 9999999999)
sprintf(c, "%dg", (int)(big / 1000000000));
else if (big > 9999999)
sprintf(c, "%dm", (int)(big / 1000000));
else if (big > 9999)
sprintf(c, "%dk", (int)(big / 1000));
else
sprintf(c, "%d", (int)(big));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movabsq $0x2540be3ff, %rax # imm = 0x2540BE3FF
cmpq %rax, 0x10(%rsp)
jbe 0x2b1888
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movl %eax, %edx
leaq 0x507ae(%rip), %rsi # 0x30202a
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::print_update(Search::search_private&) | void print_update(search_private& priv)
{
vw& all = *priv.all;
if (!priv.printed_output_header && !all.quiet)
{
const char* header_fmt = "%-10s %-10s %8s%24s %22s %5s %5s %7s %7s %7s %-8s\n";
fprintf(stderr, header_fmt, "average", "since", "instance", "current true", "current predicted", "cur", "cur",... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x180(%rsp)
movq 0x180(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x178(%rsp)
movq 0x180(%rsp), %rax
testb $0x1, 0x270(%rax)
jne 0x2b1b43
movq 0x178(%rsp), %rax
testb $0x1, 0x3439(%rax)
jne 0x2b1b43
leaq 0x506cc(%rip), %rax ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::add_neighbor_features(Search::search_private&, std::vector<example*, std::allocator<example*>>&) | void add_neighbor_features(search_private& priv, multi_ex& ec_seq)
{
if (priv.neighbor_features.size() == 0)
return;
uint32_t stride_shift = priv.all->weights.stride_shift();
for (size_t n = 0; n < ec_seq.size(); n++) // iterate over every example in the sequence
{
example& me = *ec_seq[n];
for (s... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
addq $0x18, %rdi
callq 0x2e240
cmpq $0x0, %rax
jne 0x2b24c3
jmp 0x2b2983
movq 0xc0(%rsp), %rax
movq (%rax), %rdi
addq $0x3590, %rdi # imm = 0x3590
callq 0x4c030
movl %eax, 0xb4(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::reset_search_structure(Search::search_private&) | void reset_search_structure(search_private& priv)
{
// NOTE: make sure do NOT reset priv.learn_a_idx
priv.t = 0;
priv.meta_t = 0;
priv.loss_declared_cnt = 0;
priv.done_with_all_actions = false;
priv.test_loss = 0.;
priv.learn_loss = 0.;
priv.train_loss = 0.;
priv.num_features = 0;
priv.should_produc... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq $0x0, 0x98(%rax)
movq 0x60(%rsp), %rax
movq $0x0, 0x660(%rax)
movq 0x60(%rsp), %rax
movq $0x0, 0x208(%rax)
movq 0x60(%rsp), %rax
movb $0x0, 0x240(%rax)
movq 0x60(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x244(%rax)
movq 0x60(%rsp), %rax
xorps %xmm0, %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::search_declare_loss(Search::search_private&, float) | void search_declare_loss(search_private& priv, float loss)
{
priv.loss_declared_cnt++;
switch (priv.state)
{
case INIT_TEST:
priv.test_loss += loss;
break;
case INIT_TRAIN:
priv.train_loss += loss;
break;
case LEARN:
if ((priv.rollout_num_steps == 0) || (priv.loss_declare... | movq %rdi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x208(%rax), %rcx
incq %rcx
movq %rcx, 0x208(%rax)
movq -0x8(%rsp), %rax
movl 0x6c(%rax), %eax
movl %eax, -0x10(%rsp)
subl $0x1, %eax
je 0x2b2d5d
jmp 0x2b2d44
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0x2b2d7a
jmp 0x2b2d4f
movl -0x10(%rsp), %eax
s... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::add_example_conditioning(Search::search_private&, example&, unsigned long, char const*, Search::action_repr*) | void add_example_conditioning(search_private& priv, example& ec, size_t condition_on_cnt,
const char* condition_on_names, action_repr* condition_on_actions)
{
if (condition_on_cnt == 0)
return;
uint64_t extra_offset = 0;
if (priv.is_ldf)
if (ec.l.cs.costs.size() > 0)
extra_offset = 3849017 * ec... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq %r8, 0x110(%rsp)
cmpq $0x0, 0x120(%rsp)
jne 0x2b2ebf
jmp 0x2b37ae
movq $0x0, 0x108(%rsp)
movq 0x130(%rsp), %rax
testb $0x1, 0x13(%rax)
je 0x2b2f1e
movq 0x128(%rsp), %rdi
addq $0x68... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::allowed_actions_to_ld(Search::search_private&, unsigned long, unsigned int const*, unsigned long, float const*) | polylabel& allowed_actions_to_ld(search_private& priv, size_t ec_cnt, const action* allowed_actions,
size_t allowed_actions_cnt, const float* allowed_actions_cost)
{
bool isCB = priv.cb_learner;
polylabel& ld = *priv.allowed_actions_cache;
uint32_t num_costs = (uint32_t)cs_get_costs_size(isCB, ld);
if (pri... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movb 0x68(%rax), %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x50(%rsp), %rax
movq 0x200(%rax), %rax
movq %rax, 0x20(%rsp)
movb 0x2f(%rsp), %al
movq 0x20(%rsp), %rsi
andb ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::search_predict(Search::search_private&, example*, unsigned long, unsigned int, unsigned int const*, unsigned long, unsigned int const*, char const*, unsigned int const*, unsigned long, float const*, unsigned long, float&, float) | action search_predict(search_private& priv, example* ecs, size_t ec_cnt, ptag mytag, const action* oracle_actions,
size_t oracle_actions_cnt, const ptag* condition_on, const char* condition_on_names, const action* allowed_actions,
size_t allowed_actions_cnt, const float* allowed_actions_cost, size_t learner_id,... | pushq %rbp
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movq 0x4f0(%rsp), %rax
movq 0x4e8(%rsp), %rax
movq 0x4e0(%rsp), %rax
movq 0x4d8(%rsp), %rax
movq 0x4d0(%rsp), %rax
movq 0x4c8(%rsp), %rax
movq 0x4c0(%rsp), %rax
movq %rdi, 0x498(%rsp)
movq %rsi, 0x490(%rsp)
movq %rdx, 0x488(%rsp)
movl %ecx, 0x484(%rsp)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
Search::BaseTask::Run() | void BaseTask::Run()
{
search_private& priv = *sch->priv;
// make sure output is correct
bool old_should_produce_string = priv.should_produce_string;
if (!_final_run && !_with_output_string)
priv.should_produce_string = false;
// if this isn't a final run, it shouldn't count for loss
float old_test_loss... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x68(%rsp)
movq 0x68(%rsp), %rcx
movb 0x271(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x67(%rsp)
testb $0x1, 0x10(%rax)
jne 0x2b975e
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x2b975e
movq 0... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search.cc |
EntityRelationTask::entity_first_decoding(Search::search&, std::vector<example*, std::allocator<example*>>&, v_array<unsigned long>&, bool) | void entity_first_decoding(Search::search& sch, multi_ex& ec, v_array<size_t>& predictions, bool isLdf = false)
{
// ec.size = #entity + #entity*(#entity-1)/2
size_t n_ent = (size_t)(sqrt(ec.size() * 8 + 1) - 1) / 2;
// Do entity recognition first
for (size_t i = 0; i < ec.size(); i++)
{
if (i < n_ent)
... | subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq 0x48(%rsp), %rdi
callq 0x117320
leaq 0x1(,%rax,8), %rdi
callq 0x20f680
movsd 0x16666(%rip), %xmm1 # 0x2f73b0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/search_entityrelationtask.cc |
getsock() | socket_t getsock()
{
socket_t sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock < 0)
THROWERRNO("socket");
// SO_REUSEADDR will allow port rebinding on Windows, causing multiple instances
// of VW on the same machine to potentially contact the wrong tree node.
#ifndef _WIN32
int on = 1;
if (setsocko... | subq $0x2f8, %rsp # imm = 0x2F8
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x161e0
movl %eax, 0x2f4(%rsp)
cmpl $0x0, 0x2f4(%rsp)
jge 0x2f0fdd
leaq 0x168(%rsp), %rdi
callq 0x16680
leaq 0x178(%rsp), %rdi
leaq 0x13360(%rip), %rsi # 0x3041f9
callq 0x16920
jmp 0x2f0ea0
callq 0x16080
movl (%rax), %e... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/allreduce_sockets.cc |
main | int main() {
/*
* Test Swin Transformer
*/
try {
std::cout << "Test Tiny Swin Transformer: ";
std::cout.flush();
auto *swin_t = new shift_window_transformer::SwinTransformer<data_t>(
96, std::array<int, 4>{2, 2, 6, 2},
std::array<int, 4>{3, 6, 12... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0x9bfe(%rip), %rdi # 0xbfd8
leaq 0x5d43(%rip), %rsi # 0x8124
movl $0x1c, %edx
callq 0x2190
movq 0x9be6(%rip), %rdi # 0xbfd8
callq 0x20d0
movl $0x1c8, %edi # imm = 0x1C8
callq 0x2170
movq %rax, %rbx
movaps 0x5c05(%rip), %xmm0 # 0x8010
movq %rsp, %... | /dianhsu[P]swin-transformer-cpp/main.cpp |
shift_window_transformer::Tensor<float>::~Tensor() | Tensor() : std::vector<T>() {
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x26bb
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x26d0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x2180
popq %rbx
retq
| /dianhsu[P]swin-transformer-cpp/model/tensor.h |
shift_window_transformer::SwinTransformer<float>::parameterCount() | long long parameterCount() {
return stage1.parameterCount() + stage2.parameterCount() + stage3.parameterCount() +
stage4.parameterCount() + layerNorm.parameterCount() + linear.parameterCount();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
addq $0x8, %rdi
callq 0x36b6
movq %rax, %rbx
leaq 0x68(%r12), %rdi
callq 0x36b6
movq %rax, %r14
leaq 0xc8(%r12), %rdi
callq 0x36b6
movq %rax, %r15
leaq 0x128(%r12), %rdi
callq 0x36b6
movq 0x1a8(%r12), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq... | /dianhsu[P]swin-transformer-cpp/model/swin_transformer.h |
shift_window_transformer::StageModule<float>::~StageModule() | ~StageModule() {
for (int i = 0; i < layers.size(); ++i) {
delete layers[i];
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8e84(%rip), %rax # 0xba28
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
cmpq %rdi, 0x50(%rbx)
je 0x2bf3
xorl %r12d, %r12d
leaq 0x8ecd(%rip), %r14 # 0xba88
movq (%rdi,%r12,8), %r15
testq %r15, %r15
je 0x2bcf
movq %r15, %rdi
movq %r14, %rsi... | /dianhsu[P]swin-transformer-cpp/model/stage_module.h |
shift_window_transformer::StageModule<float>::parameterCount() | long long parameterCount() {
long long ret = patch_partition.parameterCount();
for (int i = 0; i < layers.size(); ++i) {
ret += layers[i]->parameterCount();
}
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq 0x8(%rax), %rbx
subq (%rax), %rbx
sarq $0x2, %rbx
cmpb $0x1, 0x40(%rdi)
jne 0x36e5
movq 0x30(%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
addq %rcx, %rbx
movq 0x48(%r14), %rax
cmpq %rax, 0x50(%r14)
je 0x3716
xorl %r15d, %r... | /dianhsu[P]swin-transformer-cpp/model/stage_module.h |
shift_window_transformer::SwinBlock<float>::forward(shift_window_transformer::Tensor<float> const&, shift_window_transformer::Tensor<float>&) | void forward(const Tensor<T> &input, Tensor<T> &output) {
Tensor<T> tmp{};
residual1->forward(input, tmp);
residual2->forward(tmp, output);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
movq %rbx, %rdx
callq *(%rax)
movq... | /dianhsu[P]swin-transformer-cpp/model/swin_block.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.