Multithreading Analysis and its Challanges

MS-CS 3RD SEMESTER

M Shaheryar nawaz |2014-ag-5810

 Abstract
The program analysis field has focused basically on sequential programming languages. But in
multithreading it is becoming highly important, both as program structuring of mechanism and
to support most efficient parallel computations. This paper is the review for analysis in
multithreaded programs, majorly focusing on different ways to improve the efficiency of the
analyzing interactions with in threads, or to detect the data races, and to ameliorate impact of
weak memory consistency models. We have identified 2 distinct classes of multithreaded
programs, management programs and also parallel computing programs, and we discuss how these
kinds of programs structure leads to different solutions to the problems. Specifically, we finalize
that the most promising approach for activity management programs are augmented type systems
, while are the most promising approach for parallel computing programs is targeted program
analyses .In this paper analysis of multi threading and advantages or disadvantages of
multithreading and challanges are also discussed.We discussed how the new challenges arised can
create problems in future for the multi threaded programs.

PAGE 1
1. Introduction
Computer architects have modified or
bring got dramatic gains in performance
by using single thread. Each generation
of process technology doubles the
number of available transistors and, until
recently, these additional resources have
been harnessed toward improving single-
thread performance Power and memory
latency considerations place additional
obstacles to improving single-thread
performance. Further improvements is
limited in overall single-thread .Than
Chip Multi-Threaded (CMT) processors
support many simultaneous hardware
strands (or threads) of execution via a
combination of support for multiple cores
. SMT increasing latencies by enabling
multiple strands to share many of the
resources within the core, including the
execution resources. time while waiting
for off-chip misses to complete spending
a significant portion of each strand’s
utilization of the core’s execution
resources is extremely low. SMT
improves the utilization of key resources
and reduces the sensitivity of an
application to off-chip misses and
enables multiple cores to share chip
resources such as, the memory controller,
bandwidth for off-chip, and the L2 cache,
is also improving the utilization of the
resources. In this paper, we describe the
evolution of CMT processors, the CMT
design space and some of the challenges
in designing effective CMT systems.
Then to solve the problems of CMP focus
is over multithreading approach.[1]
Multithreading is a widely used
structuring technique for modern
software. Programmer uses multi threads
to control variety of problems: to build
the responsive servers that can interact at
one time with multiple clients, so to
parallely run computations on a
multiprocessor for good performance,
and structuring mechanism for
implementation of rich user interfaces.
Generally, threads are very useful
whenever software needed to manage set
of multiple tasks with varying interaction
latencies, or to exploit the multiple
physical resources, or execute the largely
independent tasks as in response to
multiple events. . Main challenge is the
developing efficient methods of
abstractions and the analyses to capture
the effect of each thread’s actions on the
other parallel threads. Multithreading
also enables many new kinds of errors in
programming ; potential severity of all
these errors and the difficulty of exposing
these errors via testing also has inspired
development in analyses that the
detection of these errors . Most of
research in this field has focused
specially on detecting data races and
researchers also have developed the
optimizations for multithreaded
programs; some of these optimizations
generalize existing optimizations for
sequential programs while others are
specific to multithreaded programs.
Multiprocessor architecture enhance
parallel processing of multi-threads. Data
race is a noticeable program in
multithreading. Mutex-lock approach
reduces the data race problem by giving
the permission with synchronous access
onshared resources. Deadlock may occur
when one tread holds the mutex-lock for
PAGE 2
one process and at the same time other
processes are continuously waiting for
that process is due the mutex-lock
approach. In multithreading approach,
the main challenge is to access the shared
resources without data race and deadlock
conditions which is resolved viably
through different implementations of
multithreading libraries.[2]
2. Use Of Analysis of
Multithreading
There are several uses proposed by
researchers for using the information
extracted from the analysis of
Multithreaded programs .
2.1 Optimization
Optimizations reorder accesses to the
shared data in many ways that may be
observed by concurrently running
threads with transformed thread. To
generalize standard program
representations, analyses, and
transformations is used to safely optimize
multithreaded programs even in accesses
to share data. Presence of multithreading
is also inspire optimizations with no true
counterpart in the optimization of step by
step or sequential programs. An other
approach is to expect that the
programmer is correctly synchronize
program or enable traditional
optimizations of compiler within any
region that does not contain an action or
that is designed to mediate the
interactions between threads . This has
the advantage that eliminates the need to
perform a expensive inter thread. The
disadvantage is that optimization can
change the result of the program
computes.
2.2. Detection of Data Race
In unsafe language as C, there are
number of programming actions that are
always cause the programmer error. If the
program engages in these actions, it can
create behavior that is difficult to
understand. Several language design and
implementation techniques can
completely eradicate these kinds of
errors. Additional cost is overhead and
loss of programmer control other aspects
of the program execution. For programs
that use threads ,analogous error is data
race, which happens when multiple
threads try to access the same data
without any intervening synchronization
operation, and one of the all accesses is a
write. A data race is always the result of
programming error, with outcome being
the corruption of accessed data structure.
The mostly used multithreaded languages
included , Java, C, and C++, leave the
programmer fully responsible for
avoiding data races correctly synchronize
the computation. As a result result uses
of threads is an inherently unsafe
programming practice.
Researchers developed a set of many
analyses to determine if a program may
have a data race. Some of analyses allow
the programmer to find an association
between data and locks, then find that the
program holds lock whenever it try to
accesses the corresponding data .
2.3. Detection of Deadlock
PAGE 1
Researchers have now developed many
types of analyses for detecting the
potential deadlocks in the programs who
uses rendezvous synchronization .A
rendezvous happens between call
statement of one thread and of accept
statement in another thread. The analyses
also match corresponding calls and then
accepts to determine if every call will
participate in rendezvous. If not, then
program is considered to be deadlock. We
find that deadlock arises from the
circular waiting to acquire the required
resources, and is a major problem in
multithreaded programs. In this way ,
programs typically use the mutual
exclusion method of synchronization
than the rendezvous synchronization. We
expect an analysis of deadlock detection
for programs that uses mutual exclusion
method of synchronization to obtain
partial order for the acquired resources
and then check that the program always
follow this order. The order could also
obtained from the programmer or may be
extracted automatically from analysis of
program.[3][1]
3 .Analysis Algorithms
Some of main issues that are arises when
we apply standard approaches for the
purpose of analyzing multithreaded
programs. We are focusing on many ways
to improve efficiency of analyzing the
interactions between multiple types of
threads.
3.1 Dataflow Analysis of
Multithreaded Programs
To discover program invariants Dataflow
analysis performs an abstract
interpretation of programs at each
program point. Conceptually, one can
also view these all analyses as a
propagating information along with
control-flow paths, and as an approach to
work reasonably as well for the
sequential programs in the part because
as each statement has less direct control-
flow successors.
The straight forward approach to
multithreaded programs to propagate all
information between statements of
parallel threads. The main issue is that
direct control-flow in successors of
statement in one of thread include the
most if all of statements is not in all
parallel threads. Propagating the
information along all of the potential
control-flow of edges leads to algorithm
with intractable execution of times. How
to reduce the numbers of paths that
analysis must be explicitly consider.
3.2 Control-Flow Analysis
One approach to analyze the program is
use of synchronization constructs for the
purpose to discover regions of all tasks
that are not executed concurrently, or
then to remove the edges between all
these regions. The main characteristics of
the analysis is to depend on specific
synchronization of constructs.
Researchers also have developed the
algorithms for all programs that use post
and wait constructs or used in parallel
dialects , for rendezvous constructs and
for Java wait or notify constructs The
basic idea algorithms to match each of
PAGE 2
blocking action with its all potential
corresponding to trigger the actions of
other threads. The analysis also uses the
information to find that statements must
execute before the trigger action or
before the statements that block action.
Generally the algorithms constructed for
post and wait are design to work with in
the parallel loops that accesses the dense
matrices. These programs uses post and
wait constructs to ensure that write in an
array element in parallel loop iteration
precedes the reads to the same element in
other iterations. The techniques therefore
focus on correlating the array accesses
with corresponding post and wait
constructs that order them. The
algorithms for rendezvous and Java wait
or notify constructs tend to more
effective for the programs in which
threads execute different in code, also
enable the analysis and distinguish
between threads at code level that thread
executes. We expect that algorithms are
less effective for server programs in
which most of threads execute in same
code.[6]
3.3 Coarsening The Analysis
Granularity
Way to reduce the analysis time by
collecting adjacent instructions from all
threads into large groups, then treat each
of the group as unit in the inter thread
analysis . To collect instructions that do
not actually interact with the other
threads; so this case show that resulting
coarsening analysis granularity do not
affect precision of final analysis result.
Because as relevant interactions take
place at the instructions of different
threads that can access the same data, the
presence of the references may also
significantly complicate determination
by which instructions can interact with
the other threads. One approach is by
interleave pointer analysis with analysis
that also determines instructions that also
interact with other thread , or another
approach would use results of an old
efficient pointer analysis just to find these
instructions .[9]s
3.4 Interference-Based Analyses
This analyses maximally coarsen analysis
granularity — they also analyze that each
thread as unit to compute result that
characterizes all interactions with the
other threads. The analysis information
that is extracted then flows from each
thread end to beginning of all other
parallel threads. For just standard bit
vector analyses as live variables and
reaching definitions, this approach is
somewhat delivers an efficient algorithm
with same precision as algorithm that
explicitly analyzes all the possible inter
leavings . For many more complicated
analyses as pointer analysis, existing
algorithms also based on this approach of
overestimating the effects of potential
interaction between threads and the lose
precision. In the end , if language
semantics rules out that the possibility
interact between tasks, or analyzing each
task as a single unit seems as obviously
the right way to proceed.[8]
3.5 Flow-Insensitive Analyses
Unlike the dataflow analyses, flow-
insensitive analyses can produce same
result or regardless of order in which
PAGE 3
statements appear in program or number conversations in separate
of times they executed . Therefore threads in some programs than
trivially extend for handling the to manage them from the same
multithreading programs. The analysis thread.
results can then be used directly or a
 Multiple_applications can be
foundation to increase the effectiveness
simultaneously accesed
of detailed flow-sensitive analyses.[3]
At a time your clients can be
connected to more than one
4. Advantages and disadvantages application
Of Multi threading  Servers are required in reduced
number
Multithreading and multi contexting are
powerful tools for increasing the
Because multiple service
performance of BEA Tuxedo
threads can dispatch by one
applications-given the appropriate
server , then the number of
circumstances., however, it is very
servers required to start your
important to understand potential
application reduced. For
benefits and disadvantages as wells.
multiple dispatched threads this
capability is especially useful
4.1 Advantages of a Multithreading specially for conversational
Multithreading offer the following servers, which must be
advantages: dedicated otherwise to one
client for purpose of
 Improved performance and conversation for entire
concurrency duration.[5]

By using multithreading 4.2 Disadvantages of a Multithreading

performance and concurrency
Multithreading present the following
for certain applications can be
disadvantages:
improved . Performance could
be unaffected or even degraded Writing code is difficult
In many applications by using
It is not easy to write
multithreading. It depends on
Multithreaded applications .
your application that how
Only experienced programmers
performance is effected.[4]
should code for these
applications.
 For conversations and remote
procedure calls it simplified
 Debugging is difficult
coding
It is harder to replicate any error
It is easy to code in different
in multithreaded application
remote procedure calls and

PAGE 4
 than it can be do in a single-
threaded program . So it is find
more difficult, in this case, to
verify and identify main causes
when errors occur.
 Difficulty in managing
concurrency
Managing concurrency task
among threads is very difficult
and has potential to introduce
some new problems into the
application.
 Difficulty in testing
Testing the multithreaded
application is difficult than
testing of a single-threaded
application because its defects
are timing-related and more
difficult in reproducing.
 Difficulty in port existing code
Significant re-architecting in
existing code is often requires to
take the advantage of
multithreading. Programmers
need to:
o Remove the static
variables
o Replace any of function to
calls that are just not
thread-safe
o Replace any of other code
that is also not the thread-
safe
Testing and re-testing should be
completed for port,as to port a
multithreaded application is
substantial the work is required.
5. Challenges
 Primary challenges to analyze
multithreaded programs is remain
a developing abstraction and
analyses can precisely
characterizes interactions
between the threads. For
explicitly interactions take place
at the synchronization constructs,
primary goal just to match the
interacting pairs to constructs.[7]
 For implicit kind of interactions
that happens at memory locations
accessed only by multiple threads,
primary goal to find instructions
that access same memory
locations, then characterizes
combined effects of the
instructions. The use of dynamic
memory allocation, object
references, and arrays
significantly complicates the
analysis of these implicit
interactions because they force
the analysis to disambiguate the
accesses to avoid analyzing
interactions that never occur
when the program runs.
 The problem is for programs that
use referencing because
interactions in instructions that
access references in turn, affect
the location that other instructions
accesses. Main challenges is to
develop efficient method of
disambiguation analyses for the
multithreaded programs..
 Most of existing analyses
assumes that a simple model of
multithreaded execution is
PAGE 5
 characterized by absence of one
and many of dynamic object
creation, dynamic thread creation,
references to objects , and
procedure or method calls. [3]
6. Conclusion
Multithreaded programs are more
complicated for analyzing than the
sequential programs. Many analyses also
have focused on characterizing the
interactions between multiple threads to
detect the safety problems as data races
and the deadlock or to hide errors
associated with weak models of memory
consistency. Future more directions
include generalizing the abstractions and
analyses to make better handle constructs
such as dynamically also allocated
memory, dynamic method of thread
creation, procedures or methods, and
threads as first-class objects. We also
anticipate that the further more
development of augmented type of
systems for race-free programs, in which
it will reduce the potential inter thread
interactions that analysis should consider
and enable development and use more
detailed through precise analyses.
7. References:
[1] X. Huang, Z. Liu, and J. Li, “Array
sort: an adaptive sorting algorithm on
multi-thread,” J. Eng., vol. 2019, no.
5, pp. 3455–3459, 2019.
[2] M. Rinard, “Analysis of
multithreaded programs,” Lect. Notes
Comput. Sci., pp. 1–19, 2001.
[3] P. Krishnamurthy, R. Karri, and F.
Khorrami, “Anomaly Detection in
Real-Time Multi-Threaded Processes
Using Hardware Performance
Counters,” IEEE Trans. Inf.
Forensics Secur., vol. PP, no. c, pp.
1–1, 2019.
[4] I. The and I. L. Parallelism, “Multi-
threading technology and the
challenges of meeting performance
and power consumption demands for
mobile applications,” no. September,
pp. 1–9, 2013.
[5] L. Yin, W. Dong, W. Liu, and J.
Wang, “Parallel Refinement for
Multi-Threaded Program
Verification,” 2019 IEEE/ACM 41st
Int. Conf. Softw. Eng., pp. 643–653,
2019.
[6] F. N. Eskesen, M. Hack, T. Kimbrel,
M. S. Squillante, R. J. Eickemeyer,
and S. R. Kunkel, “Performance
Analysis of Simultaneous
Multithreading in a PowerPC-based
Processor,” Proc. 1st Annu. Work.
Duplic. Deconstructing, Debunking
(WDDD 2002), 2002.
[7] V. Kelefouras and K. Djemame,
“Workflow Simulation Aware and
Multi-threading Effective Task
Scheduling for Heterogeneous
Computing,” Proc. - 25th IEEE Int.
Conf. High Perform. Comput. HiPC
2018, pp. 215–224, 2019.
[8] M. Zhang, Z. Zhang, Y. Dai, Q.
Wang, W. Sun, and X. Hu, “Design of
a Multi-Threaded Positioning System
Software Architecture for Ground
Mobile Robots,” Proc. - 2018 5th Int.
Conf. Inf. Sci. Control Eng. ICISCE
2018, no. 1, pp. 699–703, 2019.
[9] 宋争辉, “No Title专业外语有屁用,”
信阳师范学院, vol. 10, no. 2, pp. 1–
15, 2018.
PAGE 6
PAGE 7