PERFORMANCE ANALYSIS OF SYNCHRONISATION PROBLEM USING ASPECT ORIENTED PROGRAMMING

Submitted by:-Harshit monish9911103466F-4

OVERVIEW Cross Cutting Concerns

Logging Producer Consumer problem(synchronization)

The cost of tangled code Aspect Oriented Programming Development stage Terminology Aop benefits and oop shortcomings Producer Consumer problem

CROSS CUTTING CONCERNS:- What is a crosscutting concern?

Behavior that cuts across the typical divisions of responsibility, such as logging or debugging

A problem which a program tries to solve. Aspects of a program that do not relate to the

core concerns directly, but which proper program execution nevertheless requires

Function Requirements

Non-FunctionalRequirements

Production Code

=+

CROSS CUTTING CONCERNS:- Examples Synchronisation Logging Authorisation Exception handling

LOGGING WITHOUT AOP

LOGGING WITH AOP

PRODUCER CONSUMER PROBLEM

TWO PROBLEMS AOP TRIES TO SOLVE

TWO PROBLEMS AOP TRIES TO SOLVE

THE COST OF TANGLED CODE redundant code

same fragment of code in many places difficult to reason about

non-explicit structure the big picture of the tangling isn’t clear

difficult to change have to find all the code involved and be sure to change it consistently Poor traceability Lower productivity Less code reuse Harder refactoring

ASPECT ORIENTED PROGRAMMING AOP is a programming paradigm which aims

to increase modularity by allowing the separation of cross-cutting concerns

In AOP crosscutting concerns are implemented in aspects instead of fusing them into core modules.

Aspects can be reused. By reducing code tangling it makes it easier

to understand what the core functionality of a module is.

An “aspect weaver” takes the aspects and the core modules and composes the final system

Coding is HARD

AOP makes it EASY

AOP DEVELOPMENT STAGESIntegrating all concerns

Identify concerns

What’s in it for YOU?

BENEFITS Write less code Read less code More concise and easy to understand More maintainable Fewer code = Less boilerplate code More interesting work Increased attention More PRODUCTIVITY!

FEWER DEFECTS!

TERMINOLOGYCross-cutting – Identify areas of code

where common functionality exists Advice – The code to be injected Joinpoint – Where one or more

aspects can be appliedPointcut – A collection of joinpointsAspect – General term for where

advice and point-cuts are combined

TERMINOLOGYWeaving – Integrating applications

and aspects (e.g. AspectJ is an “aspect weaver”)

Compile-time – Can produce integrated source-code, but typically only produces woven byte-code.

Run-time – Aspects are applied “on the fly” (typically when classes are loaded)

OOP SHORTCOMINGS OOP allows to decompose a system into units of

function or behavior Certain software properties cannot be isolated in

single functional unit, instead they crosscut multiple components

Such crosscutting concerns result in tangled code that is hard to develop and maintain

AOP BENEFITS Separation of components and aspects

Better understanding of software because of high level of abstraction

Easier development and maintenance because tangling of code is prevented

Increased potential for reuse for both components as well as aspects

AOP breaks encapsulation in a controlled manner.

Encapsulation is broken between classes and aspects.

Aspects marked as privileged have access to the private members of a class.

Encapsulation is preserved between classes.

An aspect encapsulates a crosscutting concern.

WHAT ABOUT ENCAPSULATION?

PROBLEM DESCRIPTION Question: ''How to enforce synchronization

policies with AOP?''

Suppose multiple objects are concurrently working on some shared data and exclusive access is needed for modification

All objects that are working on the data must be synchronized, for example by locking the shared data temporarily

PROBLEM DESCRIPTION Question: ''How to enforce synchronization

policies with AOP?''

Suppose multiple objects are concurrently working on some shared data and exclusive access is needed for modification

All objects that are working on the data must be synchronized, for example by locking the shared data temporarily

OBSERVATION Without AOP

Every component that works on the shared data must take care of the locking itself, leading to tangled and complex code

With AOP The locking aspect is separated from the components

by means of an aspect module, resulting in usual benefits of modularization

THE PRODUCER CONSUMER ASPECT