Illegal instruction error when running Tracking and Mapping tutorial

[Dylan-Powers]

I am trying to run stella_vslam on a Ubuntu 20.04 VM through Virtual Box. I installed and built the socket and the SocketViewer through docker.

I was trying to run the Tracking and Mapping tutorial but ran into the following final error when running the mapping algorithm itself.

Illegal instruction (Illegal operand [0x7f20218b7379])
Illegal instruction (core dumped)

I apologize for the long past but this was the entire output from running that command including the command itself:

root@Ubuntu-20:/stella_vslam/build# ./run_video_slam -v orb_vocab.fbow -c ../example/aist/equirectangular.yaml -m aist_entrance_hall_1/video.mp4 --frame-skip 3 --map-db-out aist_entrance_hall_1_map.msg
[2023-05-11 04:19:30.506] [I] config file loaded: ../example/aist/equirectangular.yaml
--start-timestamp is not set. using system timestamp.
[2023-05-11 04:19:30.506] [I] 
original version of OpenVSLAM,
Copyright (C) 2019,
National Institute of Advanced Industrial Science and Technology (AIST)
All rights reserved.
stella_vslam (the changes after forking from OpenVSLAM),
Copyright (C) 2022, stella-cv, All rights reserved.

This is free software,
and you are welcome to redistribute it under certain conditions.
See the LICENSE file.

Camera:
  name: RICOH THETA S 960
  setup: monocular
  model: equirectangular
  fps: 30.0
  cols: 1920
  rows: 960
  color_order: RGB
Preprocessing:
  min_size: 800
  mask_rectangles:
    - [0.0, 1.0, 0.0, 0.1]
    - [0.0, 1.0, 0.84, 1.0]
    - [0.0, 0.2, 0.7, 1.0]
    - [0.8, 1.0, 0.7, 1.0]
Feature:
  name: default ORB feature extraction setting
  scale_factor: 1.2
  num_levels: 8
  ini_fast_threshold: 20
  min_fast_threshold: 7
Mapping:
  backend: g2o
  baseline_dist_thr_ratio: 0.02
  redundant_obs_ratio_thr: 0.95
  num_covisibilities_for_landmark_generation: 20
  num_covisibilities_for_landmark_fusion: 20
Tracking:
  backend: g2o
LoopDetector:
  backend: g2o
  enabled: true
  reject_by_graph_distance: true
  min_distance_on_graph: 50
System:
  map_format: msgpack

[2023-05-11 04:19:30.506] [I] loading ORB vocabulary: orb_vocab.fbow
[2023-05-11 04:19:30.533] [I] load orb_params "default ORB feature extraction setting"
[2023-05-11 04:19:30.534] [I] startup SLAM system
[2023-05-11 04:19:30.535] [I] start mapping module
[2023-05-11 04:19:30.536] [I] start global optimization module
[2023-05-11 04:19:30] [connect] Successful connection
[2023-05-11 04:19:30] [connect] WebSocket Connection 127.0.0.1:3000 v-2 "WebSocket++/0.8.1" /socket.io/?EIO=4&transport=websocket&t=1683778770 101
[2023-05-11 04:19:30.543] [I] connected to server
[2023-05-11 04:19:30.865] [I] initialization succeeded with E
Stack trace (most recent call last) in thread 66:
#11   Object "", at 0xffffffffffffffff, in 
#10   Object "/lib/x86_64-linux-gnu/libc.so.6", at 0x7f2021e4ebb3, in clone
#9    Object "/lib/x86_64-linux-gnu/libc.so.6", at 0x7f2021dbdb42, in pthread_condattr_setpshared
#8    Object "/lib/x86_64-linux-gnu/libstdc++.so.6", at 0x7f202204d2b2, in std::error_code::default_error_condition() const
#7  | Source "/usr/include/c++/11/bits/std_thread.h", line 211, in _M_run
    |   210: 	void
    | > 211: 	_M_run() { _M_func(); }
    |   212:       };
    | Source "/usr/include/c++/11/bits/std_thread.h", line 260, in operator()
    |   258: 	  using _Indices
    |   259: 	    = typename _Build_index_tuple<tuple_size<_Tuple>::value>::__type;
    | > 260: 	  return _M_invoke(_Indices());
    |   261: 	}
    |   262:       };
    | Source "/usr/include/c++/11/bits/std_thread.h", line 253, in _M_invoke<0>
    |   251: 	  typename __result<_Tuple>::type
    |   252: 	  _M_invoke(_Index_tuple<_Ind...>)
    | > 253: 	  { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); }
    |   254: 
    |   255: 	typename __result<_Tuple>::type
    | Source "/usr/include/c++/11/bits/invoke.h", line 96, in __invoke<mono_tracking(const std::shared_ptr<stella_vslam::system>&, const std::shared_ptr<stella_vslam::config>&, const string&, const string&, unsigned int, unsigned int, bool, bool, bool, const string&, const string&, double, bool)::<lambda()> >
    |    94:       using __type = typename __result::type;
    |    95:       using __tag = typename __result::__invoke_type;
    | >  96:       return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
    |    97: 					std::forward<_Args>(__args)...);
    |    98:     }
    | Source "/usr/include/c++/11/bits/invoke.h", line 61, in __invoke_impl<void, mono_tracking(const std::shared_ptr<stella_vslam::system>&, const std::shared_ptr<stella_vslam::config>&, const string&, const string&, unsigned int, unsigned int, bool, bool, bool, const string&, const string&, double, bool)::<lambda()> >
    |    59:     constexpr _Res
    |    60:     __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
    | >  61:     { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
    |    62: 
    |    63:   template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
      Source "/stella_vslam/example/run_video_slam.cc", line 91, in std::thread::_State_impl<std::thread::_Invoker<std::tuple<mono_tracking(std::shared_ptr<stella_vslam::system> const&, std::shared_ptr<stella_vslam::config> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unsigned int, unsigned int, bool, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, double, bool)::{lambda()#1}> > >::_M_run() [0x55fe2945af47]
         89:             if (!frame.empty() && (num_frame % frame_skip == 0)) {
         90:                 // input the current frame and estimate the camera pose
      >  91:                 slam->feed_monocular_frame(frame, timestamp, mask);
         92:             }
         93: 
         94:             const auto tp_2 = std::chrono::steady_clock::now();
#6    Source "/stella_vslam/src/stella_vslam/system.cc", line 445, in stella_vslam::system::feed_monocular_frame(cv::Mat const&, double, cv::Mat const&) [0x7f20236b5f1e]
        442:         spdlog::warn("preprocess: empty image");
        443:         return nullptr;
        444:     }
      > 445:     return feed_frame(create_monocular_frame(img, timestamp, mask), img);
        446: }
        447: 
        448: std::shared_ptr<Mat44_t> system::feed_stereo_frame(const cv::Mat& left_img, const cv::Mat& right_img, const double timestamp, const cv::Mat& mask) {
#5    Source "/stella_vslam/src/stella_vslam/system.cc", line 471, in stella_vslam::system::feed_frame(stella_vslam::data::frame const&, cv::Mat const&) [0x7f20236b3e6a]
        469:     const auto start = std::chrono::system_clock::now();
        470: 
      > 471:     const auto cam_pose_wc = tracker_->feed_frame(frm);
        472: 
        473:     const auto end = std::chrono::system_clock::now();
        474:     double elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
#4    Source "/stella_vslam/src/stella_vslam/tracking_module.cc", line 127, in stella_vslam::tracking_module::feed_frame(stella_vslam::data::frame) [0x7f20236ce617]
        125:     bool succeeded = false;
        126:     if (tracking_state_ == tracker_state_t::Initializing) {
      > 127:         succeeded = initialize();
        128:     }
        129:     else {
        130:         bool relocalization_is_needed = tracking_state_ == tracker_state_t::Lost;
#3    Source "/stella_vslam/src/stella_vslam/tracking_module.cc", line 305, in stella_vslam::tracking_module::initialize() [0x7f20236cd087]
        302:     std::lock_guard<std::mutex> lock2(mtx_stop_keyframe_insertion_);
        303: 
        304:     // try to initialize with the current frame
      > 305:     initializer_.initialize(camera_->setup_type_, bow_vocab_, curr_frm_);
        306: 
        307:     // if map building was failed -> reset the map database
        308:     if (initializer_.get_state() == module::initializer_state_t::Wrong) {
#2    Source "/stella_vslam/src/stella_vslam/module/initializer.cc", line 76, in stella_vslam::module::initializer::initialize(stella_vslam::camera::setup_type_t, fbow::Vocabulary*, stella_vslam::data::frame&) [0x7f2023776b1d]
         73:             }
         74: 
         75:             // create new map if succeeded
      >  76:             create_map_for_monocular(bow_vocab, curr_frm);
         77:             break;
         78:         }
         79:         case camera::setup_type_t::Stereo:
#1    Source "/stella_vslam/src/stella_vslam/module/initializer.cc", line 205, in stella_vslam::module::initializer::create_map_for_monocular(fbow::Vocabulary*, stella_vslam::data::frame&) [0x7f2023774b03]
        202:     map_db_->add_spanning_root(init_keyfrm);
        203: 
        204:     // compute BoW representations
      > 205:     init_keyfrm->compute_bow(bow_vocab);
        206:     curr_keyfrm->compute_bow(bow_vocab);
        207: 
        208:     // add the keyframes to the map DB
#0  | Source "/stella_vslam/3rd/FBoW/src/fbow.cpp", line 276, in fbow::Vocabulary::transform(cv::Mat const&, int, fbow::BoWVector&, fbow::BoWFeatVector&)
    |   274:     //get host info to decide the version to execute
    |   275:     if (!cpu_info){
    | > 276:         cpu_info=std::make_shared<cpu>();
    |   277:         cpu_info->detect_host();
    |   278:     }
    | Source "/usr/include/c++/11/bits/shared_ptr.h", line 879, in std::shared_ptr<fbow::cpu> std::make_shared<fbow::cpu>()
    |   877:       typedef typename std::remove_cv<_Tp>::type _Tp_nc;
    |   878:       return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
    | > 879: 				       std::forward<_Args>(__args)...);
    |   880:     }
    | Source "/usr/include/c++/11/bits/shared_ptr.h", line 863, in std::shared_ptr<fbow::cpu> std::allocate_shared<fbow::cpu, std::allocator<fbow::cpu>>(std::allocator<fbow::cpu> const&)
    |   862:       return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
    | > 863: 			     std::forward<_Args>(__args)...);
    |   864:     }
    | Source "/usr/include/c++/11/bits/shared_ptr.h", line 409, in std::shared_ptr<fbow::cpu>::shared_ptr<std::allocator<fbow::cpu>>(std::_Sp_alloc_shared_tag<std::allocator<fbow::cpu> >)
    |   407:       template<typename _Alloc, typename... _Args>
    |   408: 	shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
    | > 409: 	: __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
    |   410: 	{ }
    | Source "/usr/include/c++/11/bits/shared_ptr_base.h", line 1342, in std::__shared_ptr<fbow::cpu, (__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<fbow::cpu>>(std::_Sp_alloc_shared_tag<std::allocator<fbow::cpu> >)
    |  1340:       template<typename _Alloc, typename... _Args>
    |  1341: 	__shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
    | >1342: 	: _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
    |  1343: 	{ _M_enable_shared_from_this_with(_M_ptr); }
    | Source "/usr/include/c++/11/bits/shared_ptr_base.h", line 650, in std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<fbow::cpu, std::allocator<fbow::cpu>>(fbow::cpu*&, std::_Sp_alloc_shared_tag<std::allocator<fbow::cpu> >)
    |   648: 	  auto __guard = std::__allocate_guarded(__a2);
    |   649: 	  _Sp_cp_type* __mem = __guard.get();
    | > 650: 	  auto __pi = ::new (__mem)
    |   651: 	    _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
    |   652: 	  __guard = nullptr;
    | Source "/usr/include/c++/11/bits/shared_ptr_base.h", line 519, in std::_Sp_counted_ptr_inplace<fbow::cpu, std::allocator<fbow::cpu>, (__gnu_cxx::_Lock_policy)2>::_Sp_counted_ptr_inplace<>(std::allocator<fbow::cpu>)
    |   517: 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
    |   518: 	  // 2070.  allocate_shared should use allocator_traits<A>::construct
    | > 519: 	  allocator_traits<_Alloc>::construct(__a, _M_ptr(),
    |   520: 	      std::forward<_Args>(__args)...); // might throw
    |   521: 	}
    | Source "/usr/include/c++/11/bits/alloc_traits.h", line 516, in void std::allocator_traits<std::allocator<fbow::cpu> >::construct<fbow::cpu>(std::allocator<fbow::cpu>&, fbow::cpu*)
    |   514: 	{
    |   515: #if __cplusplus <= 201703L
    | > 516: 	  __a.construct(__p, std::forward<_Args>(__args)...);
    |   517: #else
    |   518: 	  std::construct_at(__p, std::forward<_Args>(__args)...);
    | Source "/stella_vslam/3rd/FBoW/include/fbow/cpu.h", line 61, in void __gnu_cxx::new_allocator<fbow::cpu>::construct<fbow::cpu>(fbow::cpu*)
    |    59:     bool HW_AVX512_F,HW_AVX512_PF,HW_AVX512_ER,HW_AVX512_CD,HW_AVX512_VL,HW_AVX512_BW,HW_AVX512_DQ,HW_AVX512_IFMA,HW_AVX512_VBMI;//  SIMD: 512-bit
    |    60: public:
    | >  61:     inline cpu(){  memset(this, 0, sizeof(*this)); }
    |    62:     inline void detect_host();
    |    63:     inline bool isSafeAVX(){return  HW_AVX && OS_AVX;}
    | Source "/stella_vslam/3rd/FBoW/include/fbow/cpu.h", line 61, in fbow::cpu::cpu()
    |    59:     bool HW_AVX512_F,HW_AVX512_PF,HW_AVX512_ER,HW_AVX512_CD,HW_AVX512_VL,HW_AVX512_BW,HW_AVX512_DQ,HW_AVX512_IFMA,HW_AVX512_VBMI;//  SIMD: 512-bit
    |    60: public:
    | >  61:     inline cpu(){  memset(this, 0, sizeof(*this)); }
    |    62:     inline void detect_host();
    |    63:     inline bool isSafeAVX(){return  HW_AVX && OS_AVX;}
      Source "/usr/include/x86_64-linux-gnu/bits/string_fortified.h", line 59, in fbow::Vocabulary::transform(cv::Mat const&, int, fbow::BoWVector&, fbow::BoWFeatVector&) [0x7f20218b7379]
         56: __fortify_function void *
         57: __NTH (memset (void *__dest, int __ch, size_t __len))
         58: {
      >  59:   return __builtin___memset_chk (__dest, __ch, __len,
         60: 				 __glibc_objsize0 (__dest));
         61: }

I have tried rebuilding the docker container with -DBUILD_WITH_MARCH_NATIVE=OFF and I think I did it right. I simply manually added the lines in the g2o and stella_vslam sections and ran the docker build command again.

Final note: What appears to be the first frame of the video appears in the top left corner of the SocketViewer.

Anything I can try?

[ymd-stella]

Stop using Virtual Box or stop using docker.