Caching: An Optimization Aspect

1
Caching An Optimization Aspect
2
Class Diagram for Base
Back Item Target Container Source Caching Contain
er C
contains
Item name String check() int
0..
Container capacity int check()
int addItem(Item it)void
Simple weight int check() int
3
Background

• Container/Simple both inherit from Item
  Container contains vector of Item.
• Cache the value of the sum for each container and
  the number of violations.
• If the same container is checked again and there
  has been no change, we can reuse the cached values

4
Caching Aspect

• Interface C (view it as a role)
• Can have one of its methods cached
• Requires a method allInvalidated
• Returns all objects whose caches would be
  invalidated by a modification to the current
  object
• AspectJ interfaces can provide member
  implementations and fields field cachedValue And
  method clearCache()
• Very useful! Define popular behaviors.

5
Reusable

• Use abstract pointcuts to represent the methods
  to be cached (cachedmeth) and the methods to
  invalidate caches (invalidate).
• Advice for those pointcuts.

6
Object

• Object around(..) cachedmeth
• Object cachedValue

7
Back Aspect

• Want to maintain an invariant.
• Intercept calls that can affect the invariant.

8
Old viewgraphs

• Alternative solution

9
HashTable method

• Hashtable cachenew Hashtable()
• pointcut changed(Container c)target(c)
• call( Container.addItem(..))
• before(Container c)changed(c)
  if(cache.containsKey(c))
• Container containc.getContainer()
• cache.remove(c) //invalidate
• while(contain!null) cache.remove(contain)
  containcontain.getContainer()

10

• pointcut getvalue(Item i)target(i)
• call( .check(..))
• int around(Item i)getvalue(i)
  if(cache.containsKey(i))
• return ((Integer)cache.get(i)).intValue() int
  vthisJoinPoint.proceed(i) cache.put(i,new
  Integer(v))
• return v

11
Introductions

• private int Container.violations 0
• private int Container.total 0
• private boolean
• Container.cacheIsValid false

12

• pointcut getTotal(Container c)
• call (int check(..)) target(c)
• int around (Container c) getTotal(c)
• if(c.cacheIsValid)
• System.out.println(c.name " using cached
  value for total " c.total)
• if(c.violations gt 0)
• System.out.println(c.name " had "
  c.violations " violations")
• return c.total
• else return proceed(c)

13

• after(Container c) returning (int tot)
  getTotal(c)
• c.total tot
• c.violations c.total - c.capacity
• c.cacheIsValid true

14
Adding a new item

• pointcut newItem(Container c, Item i)
  call(void setContainer(..))
• target(i) args(c)
• after(Container c, Item i) newItem(c, i)
• c.setValid(false)
• public void Container.setValid(boolean
  isValid) cacheIsValid isValid
• if(getContainer() ! null)
• getContainer().setValid(isValid)

15
What was learned?

• The Hashtable allows us to better encapsulate the
  Caching aspect, leaving us with more elegant code
  that doesnt pollute the name-space of Container
• It seems cleaner for each Container to keep track
  of its total weight. This will also probably
  shorten the run-time.

16
Part 1b/d Improving modularity and reusability

• If we dont cache, we dont need the back
  pointers in our containers. So make it an aspect!
• Improve reusability through use of abstract
  aspects.

17
Back pointer based on introductions

• private Container Item.container
• public void Item.setContainer(Container c)
• container c
• public Container Item.getContainer()
• return container

18
Setting the BP

• pointcut addingItem(Container c, Item i)
  call (void addItem(..))
• target(c) args(i)
• after(Container c, Item i) addingItem(c, i)
• i.setContainer(c)

19
Abstract Caching Aspect

• There is a Parent/Child relationship which can be
  useful in creating abstract aspects.
• interface Parent extends Child
• void addItem(Child c)
• abstract aspect Cashing
• abstract pointcut invalidate(Parent p)
• abstract pointcut cashing(Parent p)

20

• Such that we can implement interesting
  functionality based
• only on knowledge that a Parent/Child
  relationship exists.
• after(Parent p) invalidate(p)
• while(p ! null)
• beforeInvalidate(p)
• p.cashedValue -1
• p ((Child)p).getParent(
  )