Author: epbernard
Date: 2008-07-16 21:01:51 -0400 (Wed, 16 Jul 2008)
New Revision: 14942

Modified:
 search/trunk/src/java/org/hibernate/search/impl/SearchFactoryImpl.java
Log:
HSEARCH-230 use a piggyback volatile to ensure proper barrier between intitalization writes and subsequent reads. should probably be handled by Sibernate Core in the SessionFactory instead

Modified: search/trunk/src/java/org/hibernate/search/impl/SearchFactoryImpl.java
===================================================================
--- search/trunk/src/java/org/hibernate/search/impl/SearchFactoryImpl.java  2008-07-17 00:31:43 UTC (rev 14941)
+++ search/trunk/src/java/org/hibernate/search/impl/SearchFactoryImpl.java  2008-07-17 01:01:51 UTC (rev 14942)
@@(protected) @@
 private Map<String, Analyzer> analyzers;
 private final AtomicBoolean stopped = new AtomicBoolean( false );
 private final int cachingWrapperFilterSize;
+  /*
+   * used as a barrier (piggyback usage) between initialization and subsequent usage of searchFactory in different threads
+   * this is due to our use of the initialize pattern is a few areas
+   * subsequent reads on volatiles should be very cheap on most platform especially since we don't write after init
+   *
+   * This volatile is meant to be written after initialization
+   * and read by all subsequent methods accessing the SearchFactory state
+   * read to be as barrier != 0. If barrier == 0 we have a race condition, but is not likely to happen.
+   */
+  private volatile short barrier;

 /**
  * Each directory provider (index) can have its own performance settings.
@@(protected) @@


 public BackendQueueProcessorFactory getBackendQueueProcessorFactory() {
+    if (barrier != 0) { } //read barrier
   return backendQueueProcessorFactory;
 }

 public void setBackendQueueProcessorFactory(BackendQueueProcessorFactory backendQueueProcessorFactory) {
+    //no need to set a barrier, we init in the same thread as the init one
   this.backendQueueProcessorFactory = backendQueueProcessorFactory;
 }

@@(protected) @@
   this.worker = WorkerFactory.createWorker( cfg, this );
   this.readerProvider = ReaderProviderFactory.createReaderProvider( cfg, this );
   this.filterCachingStrategy = buildFilterCachingStrategy( cfg.getProperties() );
-    
   this.cachingWrapperFilterSize = ConfigurationParseHelper.getIntValue( cfg.getProperties(), Environment.CACHING_WRAPPER_FILTER_SIZE, CachingWrapperFilter.DEFAULT_SIZE );
+    this.barrier = 1; //write barrier
 }

 private static String defineIndexingStrategy(SearchConfiguration cfg) {
@@(protected) @@
 }

 public String getIndexingStrategy() {
+    if (barrier != 0) { } //read barrier
   return indexingStrategy;
 }

 public void close() {
+    if (barrier != 0) { } //read barrier
   if ( stopped.compareAndSet( false, true) ) {
     try {
       worker.close();
@@(protected) @@
 }

 public void addClassToDirectoryProvider(Class clazz, DirectoryProvider<?> directoryProvider) {
+    //no need to set a read barrier, we only use this class in the init thread
   DirectoryProviderData data = dirProviderData.get(directoryProvider);
   if (data == null) {
     data = new DirectoryProviderData();
@@(protected) @@
 }

 public Set<Class> getClassesInDirectoryProvider(DirectoryProvider<?> directoryProvider) {
+    if (barrier != 0) { } //read barrier
   return Collections.unmodifiableSet( dirProviderData.get(directoryProvider).classes );
 }

@@(protected) @@


 public Map<Class, DocumentBuilder<Object>> getDocumentBuilders() {
+    if (barrier != 0) { } //read barrier
   return documentBuilders;
 }

 public Set<DirectoryProvider> getDirectoryProviders() {
+    if (barrier != 0) { } //read barrier
   return this.dirProviderData.keySet();
 }

 public Worker getWorker() {
+    if (barrier != 0) { } //read barrier
   return worker;
 }

 public void addOptimizerStrategy(DirectoryProvider<?> provider, OptimizerStrategy optimizerStrategy) {
+    //no need to set a read barrier, we run this method on the init thread
   DirectoryProviderData data = dirProviderData.get(provider);
   if (data == null) {
     data = new DirectoryProviderData();
@@(protected) @@
 }

 public void addIndexingParameters(DirectoryProvider<?> provider, LuceneIndexingParameters indexingParams) {
+    //no need to set a read barrier, we run this method on the init thread
   dirProviderIndexingParams.put( provider, indexingParams );
 }

 public OptimizerStrategy getOptimizerStrategy(DirectoryProvider<?> provider) {
+    if (barrier != 0) {} //read barrier
   return dirProviderData.get( provider ).optimizerStrategy;
 }

 public LuceneIndexingParameters getIndexingParameters(DirectoryProvider<?> provider ) {
+    if (barrier != 0) {} //read barrier
   return dirProviderIndexingParams.get( provider );
 }

 public ReaderProvider getReaderProvider() {
+    if (barrier != 0) {} //read barrier
   return readerProvider;
 }

 public DirectoryProvider[] getDirectoryProviders(Class entity) {
+    if (barrier != 0) {} //read barrier
   DocumentBuilder<Object> documentBuilder = getDocumentBuilders().get( entity );
   return documentBuilder == null ? null : documentBuilder.getDirectoryProviders();
 }

 public void optimize() {
+    if (barrier != 0) {} //read barrier
   Set<Class> clazzs = getDocumentBuilders().keySet();
   for (Class clazz : clazzs) {
     optimize( clazz );
@@(protected) @@
 }

 public void optimize(Class entityType) {
+    if (barrier != 0) {} //read barrier
   if ( ! getDocumentBuilders().containsKey( entityType ) ) {
     throw new SearchException("Entity not indexed: " + entityType);
   }
@@(protected) @@
 }

 public Analyzer getAnalyzer(String name) {
+    if (barrier != 0) {} //read barrier
   final Analyzer analyzer = analyzers.get( name );
   if ( analyzer == null) throw new SearchException( "Unknown Analyzer definition: " + name);
   return analyzer;
@@(protected) @@
 }

 public FilterCachingStrategy getFilterCachingStrategy() {
+    if (barrier != 0) {} //read barrier
   return filterCachingStrategy;
 }

 public FilterDef getFilterDefinition(String name) {
+    if (barrier != 0) {} //read barrier
   return filterDefinitions.get( name );
 }

@@(protected) @@
 }

 public Lock getDirectoryProviderLock(DirectoryProvider dp) {
+    if (barrier != 0) {} //read barrier
   return this.dirProviderData.get( dp ).dirLock;
 }

 public void addDirectoryProvider(DirectoryProvider<?> provider) {
+    //no need to set a barrier we use this method in the init thread
   this.dirProviderData.put( provider, new DirectoryProviderData() );
 }

 public int getCachingWrapperFilterSize() {
+    if (barrier != 0) {} //read barrier
   return cachingWrapperFilterSize;
 }
 

_______________________________________________
hibernate-commits mailing list
hibernate-commits@(protected)
https://lists.jboss.org/mailman/listinfo/hibernate-commits