acs.benchmark.util

Class ConcurrentComponentAccessUtil

java.lang.Object

acs.benchmark.util.ComponentAccessUtil

acs.benchmark.util.ConcurrentComponentAccessUtil

public class ConcurrentComponentAccessUtil
extends ComponentAccessUtil

ConcurrentComponentAccessUtil extends ComponentAccessUtil, allowing to instantiate and release components concurrently.

The class owns a thread pool to execute the tasks concurrently. The size of the thread pool can be set in the constructor; otherwise a default value of defaultThreadNumber is used.

This class allows to release components in parallel by executing each release in one of the threads of the pool.

Life cycle:

• start() must be executed before using methods from this class
• stop() must be executed when the object is not needed anymore.

Author:

acaproni

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	ConcurrentComponentAccessUtil.BenchmarkTreadPoolExecutor The thread pool to add statistics to the FutureTask.
class	ConcurrentComponentAccessUtil.InstrumentedFutureTask<T> An instrumented future task contains fields useful for getting statistics.

Nested classes/interfaces inherited from class acs.benchmark.util.ComponentAccessUtil

ComponentAccessUtil.CompRefHelper

Field Summary

Fields inherited from class acs.benchmark.util.ComponentAccessUtil

compName2Comp, contSrv, logger

Constructor Summary

Constructors

Constructor and Description
ConcurrentComponentAccessUtil(ContainerServices contSrv) Constructor.
ConcurrentComponentAccessUtil(ContainerServices contSrv, int threadPoolSize) Constructor.
ConcurrentComponentAccessUtil(ContainerServices contSrv, int threadPoolSize, boolean prestartCoreThreads) Constructor.

Method Summary

Modifier and Type	Method and Description
<T extends ACSComponentOperations> java.util.concurrent.Future<T>	getDynamicComponentConcurrent(ComponentSpec compSpec, java.lang.Class<T> idlOpInterface) The parallel version of ComponentAccessUtil.getDynamicComponent(ComponentSpec, Class) gets the dynamic component in a thread of the pool.
java.util.concurrent.Future<java.lang.Void>	releaseComponentConcurrent(java.lang.String name) Releases a component in a dedicated thread of the pool.
void	releaseComponents(java.util.Collection<java.lang.String> compNames, boolean waitCompsTermination) Concurrently releases the components with the passed names.
void	start() Life cycle method: this method must be called before using methods from this class
void	stop() Life cycle method: this method must be called when the object is not needed anymore

Methods inherited from class acs.benchmark.util.ComponentAccessUtil

getCachedComponentNames, getCachedComponents, getDynamicComponent, getDynamicComponentFromContainerServices, initCompImpl, logInfo, releaseAllComponents, releaseComponent

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ConcurrentComponentAccessUtil

public ConcurrentComponentAccessUtil(ContainerServices contSrv)

Constructor.

Build the ConcurrentComponentAccessUtil with a default number of threads

Parameters:

contSrv - The ContainerServices

ConcurrentComponentAccessUtil

public ConcurrentComponentAccessUtil(ContainerServices contSrv,
                                     int threadPoolSize)

Constructor.

Parameters:

contSrv - The ContainerServices

threadPoolSize - The number of threads in the thread pool

ConcurrentComponentAccessUtil

public ConcurrentComponentAccessUtil(ContainerServices contSrv,
                                     int threadPoolSize,
                                     boolean prestartCoreThreads)

Constructor.

Parameters:

contSrv - The ContainerServices

threadPoolSize - The number of threads in the thread pool

prestartCoreThreads -

Method Detail

start

public void start()

Life cycle method: this method must be called before using methods from this class

stop

public void stop()

Life cycle method: this method must be called when the object is not needed anymore

releaseComponentConcurrent

public java.util.concurrent.Future<java.lang.Void> releaseComponentConcurrent(java.lang.String name)

Releases a component in a dedicated thread of the pool.

Note that ComponentAccessUtil#releaseComponent(compName, waitForCompRelease=false) is very similar in the sense that it is also asynchronous, making an async call to the manager instead of spawning a new thread already here in the client. The main difference though is that in this method we can measure the time it takes to release a component, which is important for performance tests.

Parameters:

name - The name of the component to deactivate

Returns:

handle to sync up with the finishing of the component release.

releaseComponents

public void releaseComponents(java.util.Collection<java.lang.String> compNames,
                              boolean waitCompsTermination)

Concurrently releases the components with the passed names.

This method overrides the base class version, bringing in a thread pool for parallel component release, instead of sequentially releaseing every component. Mostly makes sense for waitCompsTermination == true.

To avoid hanging tests, a generous timeout of 30 minutes gets applied.

Overrides:

releaseComponents in class ComponentAccessUtil

Parameters:

compNames - The names of the components to release

waitCompsTermination - if true the method waits for all the threads to terminate before returning, otherwise returns immediately

getDynamicComponentConcurrent

public <T extends ACSComponentOperations> java.util.concurrent.Future<T> getDynamicComponentConcurrent(ComponentSpec compSpec,
                                                                                                       java.lang.Class<T> idlOpInterface)

The parallel version of ComponentAccessUtil.getDynamicComponent(ComponentSpec, Class) gets the dynamic component in a thread of the pool.

Parameters:

compSpec - The spec to start the dynamic component

idlOpInterface - The idl interface of the component

Returns:

the future task to be able to get the result of the activation of the component