Multiprocessing with Python Process

Question

I'm trying to modify a Python script to multiprocess with "Process". The problem is it's not working. In a first step, the content is retrieved sequentially (test1, test2). In a second one, it is to be called in parallel (test1 and test2). There is practically no speed difference. If you execute the functions individually, you will notice a difference. In my opinion, parallelization should only take as long as the longest individual process. What am I missing here?

import multiprocessing
import time

def test1(k):
           k = k * k
           for e in  range(1, k):
                          e = e**k
def test2(k):
           k = k * k
           for e in  range(1, k):
                          e = e + 5 - 5*k ** 4000
if __name__ == '__main__':

           start = time.time()
           test1(100)
           test2(100)
           end = time.time()
           print(end-start)

           start = time.time()
           worker_1 = multiprocessing.Process(target=test1(100))
           worker_1.start()

           worker_2 = multiprocessing.Process(target=test2, args=(100,))
           worker_2.start()

           worker_1.join()
           worker_2.join()
           end = time.time()
           print(end-start)

I want to add that I checked the task manager and saw that only 1 core is used. (4 real Core only 25% CPU => 1Core 100% used)

I know Pool Class, but I don't want to use it.

Thank you for your help.

Update

Hello, everybody, the one with the "typo" was unfavorable. Sorry about that. Bakuriu, thank you for your answer. In fact, you're right. I think it was the typo and too much work. :-( So I changed the example once again. For all who are interested:

I create two functions, in the first part of the main I run 3 times the functions sequentially. My computer needs approx. 36 sec. Then I start two new processes. These calculate their results here in parallel. As a small addition, the skin process of the program itself also calculates the function test1, which should show that the main program itself can also do something. I get a computing time of 12 sec. So that it is comprehensible for all in the Internet, what this means I once attached a picture here. Task Manager

import multiprocessing
import time

def test1(k):
           k = k * k
           for e in  range(1, k):
                          e = e**k

def test2(k):
           k = k * k
           for e in  range(1, k):
                          e = e**k

if __name__ == '__main__':


           start = time.time()
           test1(100)
           test2(100)
           test1(100)
           end = time.time()
           print(end-start)


           start = time.time()
           worker_1 = multiprocessing.Process(target=test1, args=(100,))
           worker_1.start()

           worker_2 = multiprocessing.Process(target=test2, args=(100,))
           worker_2.start()

           test1(100)

           worker_1.join()
           worker_2.join()
           end = time.time()
           print(end-start)

Answer 1

Your code is executing sequentially because instead of passing test1 to the Process's target argument you are passing test1's result to it!

You want to do this:

worker_1 = multiprocessing.Process(target=test1, args=(100,))

As you do in the other call not this:

worker_1 = multiprocessing.Process(target=test1(100))

This code is first executing test1(100), then returns None and assigns that to target spawning an "empty process". After that you spawn a second process that executes test2(100). So you execute the code sequentially plus you add the overhead of spawning two processes.