def read(self, read_list, verbose=False, log=False, n_per_proc=None):
        "Perform the actual reading."
        ret = []
        self.prep_input(read_list)
        L = len(self.file_list)
        if L == 0:
            return ret
        logger.info("Beginning to run sparser.")
        output_file_list = []
        if log:
            log_name = 'sparser_run_%s.log' % _time_stamp()
            outbuf = open(log_name, 'wb')
        else:
            outbuf = None
        try:
            if self.n_proc == 1:
                for fpath in self.file_list:
                    outpath, _ = self.read_one(fpath, outbuf, verbose)
                    if outpath is not None:
                        output_file_list.append(outpath)
            else:
                if n_per_proc is None:
                    n_per_proc = max(1, min(1000, L//self.n_proc//2))
                pool = None
                try:
                    pool = Pool(self.n_proc)
                    if n_per_proc is not 1:
                        batches = [self.file_list[n*n_per_proc:(n+1)*n_per_proc]
                                   for n in range(L//n_per_proc + 1)]
                        out_lists_and_buffs = pool.map(self.read_some,
                                                       batches)
                    else:
                        out_files_and_buffs = pool.map(self.read_one,
                                                       self.file_list)
                        out_lists_and_buffs = [([out_files], buffs)
                                               for out_files, buffs
                                               in out_files_and_buffs]
                finally:
                    if pool is not None:
                        pool.close()
                        pool.join()
                for i, (out_list, buff) in enumerate(out_lists_and_buffs):
                    if out_list is not None:
                        output_file_list += out_list
                    if log:
                        outbuf.write(b'Log for producing output %d/%d.\n'
                                     % (i, len(out_lists_and_buffs)))
                        if buff is not None:
                            buff.seek(0)
                            outbuf.write(buff.read() + b'\n')
                        else:
                            outbuf.write(b'ERROR: no buffer was None. '
                                         b'No logs available.\n')
                        outbuf.flush()
        finally:
            if log:
                outbuf.close()
                if verbose:
                    logger.info("Sparser logs may be found at %s." %
                                log_name)
        ret = self.get_output(output_file_list)
        return ret