docs: def load_mp(cls, file_pointer, _mft_config=None):
          '''The initialization process takes a file like object "file_pointer"
          and loads it in the internal structures. "use_cores" can be definied
          if multiple cores are to be used. The "size" argument is the size
          of the MFT entries. If not provided, the class will try to auto detect
          it.
          '''
          import multiprocessing
          import queue
  
          mft_config = _mft_config if _mft_config is not None else MFT.mft_config
          mft_entry_size = mft_config["entry_size"]
          #self.entries = {}
  
          if not mft_entry_size:
              mft_entry_size = MFT._find_mft_size(file_pointer)
          file_size = _get_file_size(file_pointer)
          if (file_size % mft_entry_size):
              #TODO error handling (file size not multiple of mft size)
              MOD_LOGGER.error("Unexpected file size. It is not multiple of the MFT entry size.")
  
          end = int(file_size / mft_entry_size)
  
          #setup the multiprocessing stuff
          queue_size = 10
          n_processes = 3
          manager = multiprocessing.Manager()
          buffer_queue_in = manager.Queue(queue_size)
          buffer_queue_out = manager.Queue(queue_size)
          entries = manager.dict()
          temp_entries = manager.list()
          processes = [multiprocessing.Process(target=MFT._load_entry, args=(mft_config, buffer_queue_in, buffer_queue_out, entries, temp_entries)) for i in range(n_processes)]
          for p in processes:
              p.start()
          for i in range(queue_size):
              buffer_queue_out.put(bytearray(mft_entry_size))
          #start the game
          for i in range(0, end):
              try:
                  data_buffer = buffer_queue_out.get(timeout=1)
                  file_pointer.readinto(data_buffer)
                  buffer_queue_in.put((i, data_buffer))
                  #print("adding", i)
              except queue.Empty as e:
                  print("DAMN")
                  raise
  
          for i in range(queue_size):
              buffer_queue_in.put((-1, None))
          for p in processes:
              p.join()
          print("LOADING DONE")
  
          #process the temporary list and add it to the "model"
          for entry in temp_entries:
              base_record_ref = entry.header.base_record_ref
              if base_record_ref in entries: #if the parent entry has been loaded
                  if MFT._is_related(entries[base_record_ref], entry):
                      entries[base_record_ref].copy_attributes(entry)
                  else: #can happen when you have an orphan entry
                      entries[i] = entry