Volume 5, Issue 10, October – 2020 International Journal of Innovative Science and Research Technology

ISSN No:-2456-2165

Performance Analysis of Network Port Scanning

When Using Sequential Processing, Multithreading
and Multiprocessing in Python
Programming Language
Ante Projić Frane Marjanica
University College of Management and Design ASPIRA University College of Management and Design ASPIRA
Split, Croatia Split, Croatia

Abstract:- This paper contains an analysis of sequential

processing, multithreading, and multiprocessing of a Concurrent programming is not equivalent to parallel
simple application based on Python programming programming. Concurrency is a property that specifies that
language. Due to the availability of powerful hardware, some operations can be run simultaneously, but that is not
parallelism and concurrency have become an efficient necessarily the case. Parallelism is a property that specifies
and powerful solution when considering software that operations are being run simultaneously. Concurrent
performance. Execution times are a significant factor to threads or processes will not necessarily be running in the
look at when designing and implementing software. In same instant, wherein parallelism two or more processes or
this paper, we analyze the software performance threads literally run at the same time.
regarding sequential processing, concurrency and
parallelism and its impact on execution times when using II. PARALLELISM AND CONCURRENCY IN
network port scanning. The analysis is based on three PYTHON PROGRAMMING LANGUAGE
separate implementations of the same function and its
performance on the same network subnet, same Parallel computing fulfills a need for the increased and
hardware, and operating system. We will show that efficient performance of applications. Parallel computing
multithreading and multiprocessing have a significant enables the simultaneous use of multiple computing
performance impact on software analyzed when using resources to enable processing that can be executed on
repetitive executions and that we are able to improve the multiple CPUs or CPU cores. The processing problem can be
performance of our application. The results obtained will broke down into discrete pieces that can be processed
provide insights into the parallel capabilities of Python simultaneously, and each piece can be further divided into a
programming language, and it will show the differences series of serially executed instructions on different CPUs or
between multithreading and multiprocessing techniques. CPU cores. Not to be confused with parallel computing,
We will explore both models for parallel computing. The concurrent programming denotes executing several
purpose of this paper is to explore the implementation of operations concurrently in overlapping periods. The most
multithreading and multiprocessing in Python widely used programming approach for the management of
programming language and its potential limitations and concurrency is based on multithreading. In concurrent
implementation suggestions. programming, an application is made by a single process that
is divided into multiple independent threads.
Keywords:- Concurrency, Multiprocessing, Multithreading,
Parallelism, Sequential Processing. Python programming language has built-in libraries that
enable the use of most common programming methods that
I. INTRODUCTION deal with concurrent or parallel execution, and those are
multiprocessing and multithreading.
Parallel computing fulfills a need for the increased and
efficient performance of applications. Parallel computing A process in Python is an independent sequence of
enables the simultaneous use of multiple computing execution that has its own memory space. Its memory space
resources to enable processing that can be executed on is not shared with other processes. Thread is also an
multiple CPUs or CPU cores. The processing problem can be independent sequence of execution that shares its memory
broke down into discrete pieces that can be processed space with other threads that belong to the program. A thread
simultaneously, and each piece can be further divided into a runs on a single processor, and therefore only one can be run
series of serially executed instructions on different CPUs or at a time where processes run on separate processors. The
CPU cores. Not to be confused with parallel computing, most important difference between the two is that
concurrent programming denotes executing several concurrency effectively hides latency and gives an illusion of
operations concurrently in overlapping periods. simultaneity where parallelism executes tasks at the same

IJISRT20OCT169 www.ijisrt.com 552

Volume 5, Issue 10, October – 2020 International Journal of Innovative Science and Research Technology
ISSN No:-2456-2165
time. Threads allow dividing the main control flow of a import datetime, socket, time, sys, threading, Queue,
program into multiple concurrently running control streams. multiprocessing
Threads allow the creation of concurrent pieces of the
program where each piece accesses the same memory space def port_scanner(PortNumber):
and variables. In contrast, processes have their own memory
space and resources. Also, starting threads is computationally tcp_sock = socket.socket(socket.AF_INET,
less expensive and requires fewer resources than starting socket.SOCK_STREAM)
processes. result = tcp_sock.connect_ex((targetIP, PortNumber))
if result == 0:
Concurrency and parallelism can be of extreme return PortNumber
significance for the performance of software programs, tcp_sock.close()
especially those that are CPU and I/O heavy. For example,
I/O operations cause a lot of delays in execution due to def host_info():
frequent waits from an external resource like a network. host_name = socket.gethostname()
ip_address = socket.gethostbyname(host_name)
This paper will demonstrate the impact of sequential print "Program is run on this host:"
and concurrent executions on a port scanning program, and print "Hostname: %s" % host_name
how performance changes with different parameters. Since print "IP address: %s" % ip_address
port scanning spends most of its time waiting for a network print "Timestamp:"
request to complete, we can implement concurrency so that print datetime.datetime.now()
in those times that is spent on waiting for another task to
complete another task runs. def get_target_host():

III. IMPLEMENTING PORT SCANNING IN print "---------------------------------------------------------"

PYTHON print "Enter FQDN host address for scanning:"
target = raw_input(">> ")
Our experiment with serial, concurrent and parallel targetIP = socket.gethostbyname(target)
execution is based on a program developed in Python print "Scanning host %s, IP address: %s" % (target,
(Python v2.7.5) which implements the basic functionality of targetIP)
port scanning on a single host. For port scanning, we are print "Enter port range:"
using socket library in Python. Determinating if the port is start = raw_input("Start port >> ")
open is done via socket.connect_ex(address) function where end = raw_input("End port >> ")
the return error indicator of 0 means that the port is open and return [start, end, targetIP];
connection has been successfully established. Socket global
timeout is defined by using the function socket. Set default def threader():
timeout(timeout) where it is set at 0.5 seconds. Queue library while True:
is used for safely exchanging information between threads. worker = q.get()
There are three main functions in which is port scanning result_mt.append(port_scanner(worker))
implemented. Function serial_port_scanner() implements q.task_done()
basic serial execution where all port scans are done
sequentially. Function multithreading_port_scanner() def pool_handler(ports, number_of_processes):
implements concurrent execution via multithreading by using
Python built-in threading library. User can specify the pool =
number of threads which will be spawned. Function multiprocessing.Pool(processes=number_of_processes)
multiproccesing_port_scanner() implements parallel pool.map(port_scanner, ports)
execution via multiprocessing by using Python built-in
multiprocessing library. def serial_port_scanner():
print "SERIAL Port scan starting!!!"
A. Source code for application start_time = time.time()
######################################### result_se = []
# port_scanning.py # #
Ante Projić # for PortNumber in ports:
# PERFORMANCE ANALYSIS OF NETWORK ## result_se.append(port_scanner(PortNumber))
PORT SCANNING WHEN USING SEQUENTIAL # # for port in result_se:
PROCESSING, MULTITHREADING AND # # if port == None:
MULTIPROCESSING IN PYTHON # pass
# PROGRAMMING LANGUAGE # else:
# # print "##Port %d is OPEN##" % port
#########################################
elapsed_time = time.time() - start_time
print "SERIAL Port scan finished!!!"

IJISRT20OCT169 www.ijisrt.com 553

Volume 5, Issue 10, October – 2020 International Journal of Innovative Science and Research Technology
ISSN No:-2456-2165
print "Time elapsed for SERIAL execution: %s " % print "##Port %d is OPEN##" % port
elapsed_time elapsed_time = time.time() - start_time
print "MULTIPROCESSING Port scan finished!!!"
def multithreading_port_scanner(): print "Time elapsed for MULTIPROCESSING
print "MULTITHREADING Port scan starting!!!" execution: %s " % elapsed_time
global q, result_mt
q = Queue.Queue() if __name__ == '__main__':
print "Enter number of threads:"
number_of_threads = int(raw_input(">> "))
result_mt = [] socket.setdefaulttimeout(0.5)
start_time = time.time() target_variables = []
for x in range(number_of_threads): scanlist = []
t = threading.Thread(target=threader)
t.daemon = True host_info()
t.start() target_variables = get_target_host()
for worker in ports: ports = range(int(target_variables[0]),
q.put(worker) int(target_variables[1]) + 1)
q.join() targetIP = target_variables[2]
for port in result_mt:
if port == None: for x in ports:
pass scanlist.append(x)
else:
print "##Port %d is OPEN##" % port try:
elapsed_time = time.time() - start_time serial_port_scanner()
print "MULTITHREADING Port scan finished!!!" print "-------------------------------------------------------
print "Time elapsed for MULTITHREADING execution: \n\n"
%s " % elapsed_time multithreading_port_scanner()
print "-------------------------------------------------------
def multiprocessing_port_scanner(): \n\n"
print "MULTIPROCESSING Port scan starting!!!" multiprocessing_port_scanner()
host_cpu_count = multiprocessing.cpu_count() except KeyboardInterrupt:
print "Number of CPUs in this host is %d" % print "You pressed Ctrl+C. Exiting program."
host_cpu_count sys.exit()
print "Enter number of proccesses:"
number_of_processes = int(raw_input(">> ")) B. Performance with serial, concurrent and parallel
start_time = time.time() implementations
pool = The application was run on a Linux host (Red Hat
multiprocessing.Pool(processes=number_of_processes) Enterprise Linux Server release 7.5 (Maipo)) with 4 CPUs.
Port scanning was done on a remote host with a total of 28
result_mp = pool.map(port_scanner, scanlist) ports in listening state. The host was scanned for 1 port, 10
for port in result_mp: ports, 100 ports, 1024 ports, and all 65535 ports respectively.
if port == None: Every iteration of scanning was using serial, multithreading
pass and multiprocessing techniques. Full results from the
else: experiment are available in the table below.

Execution time on 1 Execution time on Execution time on Execution time on

port 100 ports 1024 ports 65535 ports
Serial 0.003sec 0.33sec 3.48sec 218.74sec
Multithreading with 10 threads 0.008sec 0.04sec 0.38sec 22.51sec
Multiprocessing with 10
0.039sec 0.07sec 0.37sec 21.57sec
processes
Multithreading with 100 threads 0.029sec 0.06sec 0.31sec 17.81sec
Multiprocessing with100
0.33sec 0.40sec 1.60sec 71.97sec
processes
Multithreading with 200 threads 0.05sec 0.09sec 0.32sec 18.07sec
Multiprocessing with 200
0.91sec 1.10sec 2.38sec 61.29sec
processes
a. Execution times

IJISRT20OCT169 www.ijisrt.com 554

Volume 5, Issue 10, October – 2020 International Journal of Innovative Science and Research Technology
ISSN No:-2456-2165
IV. CONCULSION

Benchmark results show that in this particular instance

multithreading is far superior to serial execution and that it
also performs better than multiprocessing. Firstly,
multiprocessing has an overhead, it takes longer to spawn a
process when compared to multithreading. Multithreading
doesn’t have as much overhead since the threads can read the
same object without creating a copy. Global Interpreter Lock
(GIL) in Python is a form of a bottleneck when using
multithreading in Python as it allows maxing out only one
processor and it prevents execution of multiple threads at
once in Python. GIL is a thread-safe mechanism that is used
to prevent threads from writing to the same location in
memory, and it prevents parallel threads from executing on
multiple cores. Therefore, GIL prevents conflicts between
threads by executing only one statement at a time.

In this application, multithreading performed

significantly better than serial execution which was expected
since we are dealing with an I/O (input/output) processing
and in time that is spent waiting on a request another thread
is spawned and executed. Multiprocessing also cannot scale
well in this type of repetitive tasks that are I/O heavy since
using more processes than there are available CPUs leads to
competition for CPU resources. Contrary, if we were
analyzing a processing task that is CPU heavy multithreading
might not perform better than serial execution since only one
thread could be executed at any given time, and taking into
account the time needed to perform a switch between threads,
execution time would most likely be worse on multithreading
approach than using serial execution. Multiprocessing would
be expected to be far superior to serial and multithreading in
that case because it would use all available processors in the
system.

Multithreading is best for I/O tasks and hiding latency,

while multiprocessing performs better for computations. We
can conclude that threads are not recommended for use in
CPU bound tasks, but they are extremely effective in I/O
tasks like network IO as in this example and in filesystem
I/O.

REFERENCES

[1]. A. Zaccone, “Python parallel programming cookbook”,

Packt Publishing Ltd, 2019.
[2]. S. Kumar, “Python : threading vs multiprocessing”
unpublished.
[3]. S. Ghosh “Multiprocessing vs. threading in python:
what every data scientist needs to know” unpublished.
[4]. J. Palach, “Parallel programming with python,” Packt
Publishing Ltd, 2019.

IJISRT20OCT169 www.ijisrt.com 555