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.

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