Устранение узкого места в многопроцессной программе

''' Counting specified key sequence in the specified file
and printing result to the standard output with elapsed time '''
 
import sys
import argparse
from multiprocessing import Manager, Process
 
from timeit import default_timer as timer
 
def worker(lines_slices, keyseq, results):
    counter = 0
 
    # подсчет количества совподений в каждой строке
    for line in lines_slices:
        counter += line.count(keyseq)
 
    # сохранение результата подсчета в очереде
    results.put(counter)
 
def main(argv_slice):
    res = 0
 
    # разбор аргументов командной строки
    parser = argparse.ArgumentParser(
        description='Counting key sequence in the file')
 
    parser.add_argument('-f', '--fpath', type=str, required=True,
                        help='File path to reading')
    parser.add_argument('-k', '--keyseq', type=str, required=True,
                        help='Key sequence to counting')
 
    parsed_argv = parser.parse_args(argv_slice)
 
    fpath = parsed_argv.fpath
    keyseq = parsed_argv.keyseq
 
    with open(fpath) as fin:
        start = timer()
 
        manager = Manager()
 
        # считывание всего содержимого исходного файла
        lines = fin.readlines()
 
        # создание очереди для хранения результатов
        results = manager.Queue()
 
        processes_list = [] # список процессов
 
        lines_slices = [] # список ссылок на данные
 
        processes_count = 1
 
        process_part = len(lines) / processes_count
 
        # цикл инициализации и создания потоков выполнения
        for process_index in range(0, processes_count):
            from_index = process_index * int(process_part)
 
            if process_index != processes_count - 1:
                to_index = from_index + int(process_part)
            else:
                to_index = len(lines)
 
            # создание дополнительной ссылки на данные для каждого потока !!!
            lines_slices.append(lines[from_index:to_index])
 
            # сохранение дескриптора потока в списке потоков
            processes_list.append(Process(target=worker,
                                          args=(lines_slices[process_index],
                                                keyseq, results)))
 
            processes_list[process_index].start()
 
        # ожидание завершения потоков выполнения
        for process_index in range(0, processes_count):
            processes_list[process_index].join()
 
        custom_counter = 0
 
        # расчет окончательного результата подсчета
        for process_index in range(0, processes_count):
            custom_counter += results.get()
 
        elapsed = timer() - start # расчет затраченного времени на вычисление
 
    print('Counter: {}'.format(custom_counter))
    print('Elapsed: {}'.format(elapsed))
    
    return res
 
if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))

''' Counting specified key sequence in the specified file
and printing result to the standard output with elapsed time '''
 
import sys
import argparse
from multiprocessing import Manager, Pool
 
from timeit import default_timer as timer
 
keyseq = str()
results = None
 
def worker_init(first, second):
    global keyseq
    global results
 
    keyseq = first
    results = second
 
def worker(lines_slices):
    global keyseq
    global results
    
    counter = 0
 
    # подсчет количества совподений в каждой строке
    for line in lines_slices:
        counter += line.count(keyseq)
 
    # сохранение результата подсчета в очереде
    results.put(counter)
 
def main(argv_slice):
    res = 0
 
    # разбор аргументов командной строки
    parser = argparse.ArgumentParser(
        description='Counting key sequence in the file')
 
    parser.add_argument('-f', '--fpath', type=str, required=True,
                        help='File path to reading')
    parser.add_argument('-k', '--keyseq', type=str, required=True,
                        help='Key sequence to counting')
 
    parsed_argv = parser.parse_args(argv_slice)
 
    fpath = parsed_argv.fpath
    keyseq = parsed_argv.keyseq
 
    with open(fpath) as fin:
        start = timer()
 
        manager = Manager()
 
        # считывание всего содержимого исходного файла
        lines = fin.readlines()
 
        # создание очереди для хранения результатов
        results = manager.Queue()
 
        pool_size = 1
 
        pool = Pool(processes=pool_size, initializer=worker_init,
                    initargs=[keyseq, results])
 
        pool_size *= 1 # теперь pool_size определяет количество порций данных
 
        lines_slices = [] # список ссылок на данные
 
        pool_part = len(lines) / pool_size
 
        # цикл разбиения даннных на равные порции
        for pool_index in range(0, pool_size):
            from_index = pool_index * int(pool_part)
 
            if pool_index != pool_size - 1:
                to_index = from_index + int(pool_part)
            else:
                to_index = len(lines)
 
            lines_slices.append(lines[from_index:to_index])
 
        pool.map(worker, lines_slices)
 
        pool.close()
 
        pool.join();
 
        custom_counter = 0
 
        # расчет окончательного результата подсчета
        while not results.empty():
            custom_counter += results.get()
 
        elapsed = timer() - start # расчет затраченного времени на вычисление
 
    print('Counter: {}'.format(custom_counter))
    print('Elapsed: {}'.format(elapsed))
    
    return res
 
if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))