SEKE 2012 Proceedings - Knowledge Systems Institute

A thread is the basic unit to which the operating system
allocates processor time. Thus the CPU utilization of a bundle
is the sum of the CPU time consumed by different threads,
which execute within the bundle. We have two monitoring
perspectives that are bundle and thread. From the bundle
perspective, threads are grouped into different bundles, and
each thread belongs to a specific bundle. Thus we add the CPU
time of every thread in the bundle. From the thread perspective,
a thread execution is divided into some stages, each of which
belongs to a specific bundle. Thus we add the CPU time of
every stage in the bundle. Because of the frequent interactions
between bundles by service invocation, the relations between
bundles and threads vary dynamically. If we follow the first
perspective, the thread schedule model should be modified, and
significant overhead will be introduced as presented in [8].
Therefore, we adopt the second choice through tracing thread
transfer between bundles.
It is easy to calculate CPU time utilized by a thread during
a period using the JVMTI [22] provided by the JVM (Java
Virtual Machine). Thus, how to divide the CPU time of a
thread into different bundles becomes an essential question.
A. Monitoring Dynamic Service Invocation
Algorithm 1 describes the method of monitoring bundle
CPU utilization. Every thread is tagged with a bundle ID, when
a thread is created. OSGi invokes start () method in the
Activator class to start the bundle, when a bundle is initialized.
We set the bundle ID of the thread as the started bundle
through labeling the thread before and after the start method in
the OSGi platform (line 1-3). When a new thread is created, we
set the bundle ID of the thread as that of its parent thread (line
4-8). A thread in bundles is traced to decide whether the thread
transfer happens. When a service is invoked, if the service
provider and the service consumer are in different bundles,
thread transfer happens (line 9-12).
Service proxy is generated and used to provide services.
We use an event-driven mechanism to trace service invocation
through listening to the events in the service registry. To avoid
affecting the execution code in t he original bundle and deal
with the arriving services during execution, we create a proxy
object for every required service (line 13-16). Figure 4
describes the event-driven monitoring method. A proxy class is
generated when a service is registered. The proxy class is
instantiated when the service is invoked. We also modify the
service registry to redirect service requests to the service proxy.
Thus the proxy object instead of the original service provides
Figure 1 Proxy Generation
service for a service consumer transparently. In every proxy
class, the monitoring point is ins erted before and after the
service invocation to label the changed bundle ID of a thread.
The CPU time of every bundle is calculated. If the bundle
ID of a thread varies after entering the invoked service, the
CPU time is calculated and added to the original bundle, and
the time stamp is updated (line 17-21). After exiting from the
service, the CPU time is calculated and added to the invoked
bundle (line 22-28). Finally, the monitor calculates the CPU
utilization for every bundle in period (line 29-31).
Algorithm 1Bundle CPU monitoring
Input: OSGi-based software
Output: u 1 ,u 2 ,…,u n , where n is the number of bundles
1. LISTEN (bundle b is initialized)
2. SET the bundle ID of thread t as b ;
3. SET time stamp for t ;
4. LISTEN (thread ts is initialized)
5. GET current thread tp; //tp is the parent of ts
6. GET bundle ID of tp as bp;
7. CREATE new thread ts;
8. SET bundleID of ts as bp;
9. LISTEN (service s i invoke service s j )
10. GET the bundle ID of s i as b i ;
11. GET the bundle ID of s j as b j ;
12. IF (b i != b j )
13. GET proxy of s j as p j ;
14. IF (p j = NULL)
15. CREATE p j for s j ;
16. ENDIF
17. GET bundle_info i of b i ;
18. GET current thread t;
19. bundle_info i .CPUTime += t.Calculate_CPU();
20. SET time stamp for t ;
21. SET bundle ID of thread t as b j ;
22. EXECUTE p ;
23. GET bundle_info j of b j ;
24. bundle_Info j .CPUTime += t.Calculate_CPU() ;
25. SET time stamp for t ;
26. SET bundle ID of t as b i ;
27. EXIT p ;
28. ENDIF
29. FOR (i=1;i