Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

Further improvements to cache locking. 

In particular, don't hold cache lock while doing computations.
8.0
Jeff Young 2 years ago
parent
0f8dac81cb
commit
6ced4f72d0
7 changed files with 91 additions and 78 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      pcbnew/board.cpp
  2. 2
      pcbnew/board.h
  3. 6
      pcbnew/drc/drc_cache_generator.cpp
  4. 2
      pcbnew/drc/drc_test_provider_disallow.cpp
  5. 18
      pcbnew/pcbexpr_evaluator.cpp
  6. 57
      pcbnew/pcbexpr_functions.cpp
  7. 32
      pcbnew/zone.cpp

2
pcbnew/board.cpp
View File

@ -263,7 +263,7 @@ void BOARD::IncrementTimeStamp()
|| !m_ZoneBBoxCache.empty()
|| m_CopperItemRTreeCache )
{
std::unique_lock<std::shared_mutex> cacheLock( m_CachesMutex );
std::unique_lock<std::shared_mutex> writeLock( m_CachesMutex );
m_IntersectsAreaCache.clear();
m_EnclosedByAreaCache.clear();

2
pcbnew/board.h
View File

@ -1227,7 +1227,7 @@ public:
};
// ------------ Run-time caches -------------
std::shared_mutex m_CachesMutex;
mutable std::shared_mutex m_CachesMutex;
std::unordered_map<PTR_PTR_CACHE_KEY, bool> m_IntersectsCourtyardCache;
std::unordered_map<PTR_PTR_CACHE_KEY, bool> m_IntersectsFCourtyardCache;
std::unordered_map<PTR_PTR_CACHE_KEY, bool> m_IntersectsBCourtyardCache;

6
pcbnew/drc/drc_cache_generator.cpp
View File

@ -137,7 +137,7 @@ bool DRC_CACHE_GENERATOR::Run()
std::future<void> retn = tp.submit(
[&]()
{
std::unique_lock<std::shared_mutex> cacheLock( m_board->m_CachesMutex );
std::unique_lock<std::shared_mutex> writeLock( m_board->m_CachesMutex );
if( !m_board->m_CopperItemRTreeCache )
m_board->m_CopperItemRTreeCache = std::make_shared<DRC_RTREE>();
@ -185,8 +185,10 @@ bool DRC_CACHE_GENERATOR::Run()
rtree->Insert( aZone, layer );
}
std::unique_lock<std::shared_mutex> cacheLock( m_board->m_CachesMutex );
{
std::unique_lock<std::shared_mutex> writeLock( m_board->m_CachesMutex );
m_board->m_CopperZoneRTreeCache[ aZone ] = std::move( rtree );
}
done.fetch_add( 1 );
}

2
pcbnew/drc/drc_test_provider_disallow.cpp
View File

@ -154,7 +154,7 @@ bool DRC_TEST_PROVIDER_DISALLOW::Run()
PTR_PTR_LAYER_CACHE_KEY key = { ruleArea, copperZone, UNDEFINED_LAYER };
{
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_IntersectsAreaCache[ key ] = isInside;
}

18
pcbnew/pcbexpr_evaluator.cpp
View File

@ -61,12 +61,18 @@ public:
wxPGChoices& layerMap = ENUM_MAP<PCB_LAYER_ID>::Instance().Choices();
const wxString& layerName = b->AsString();
BOARD* board = static_cast<PCBEXPR_CONTEXT*>( aCtx )->GetBoard();
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_LayerExpressionCache.find( layerName );
if( i != board->m_LayerExpressionCache.end() )
return i->second.Contains( m_layer );
}
LSET mask;
if( i == board->m_LayerExpressionCache.end() )
{
for( unsigned ii = 0; ii < layerMap.GetCount(); ++ii )
{
wxPGChoiceEntry& entry = layerMap[ii];
@ -75,11 +81,9 @@ public:
mask.set( ToLAYER_ID( entry.GetValue() ) );
}
board->m_LayerExpressionCache[ layerName ] = mask;
}
else
{
mask = i->second;
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_LayerExpressionCache[ layerName ] = mask;
}
return mask.Contains( m_layer );

57
pcbnew/pcbexpr_functions.cpp
View File

@ -128,6 +128,8 @@ static void existsOnLayerFunc( LIBEVAL::CONTEXT* aCtx, void *self )
aCtx->ReportError( wxString::Format( _( "Unrecognized layer '%s'" ),
layerName ) );
}
return 0.0;
}
else
{
@ -136,12 +138,18 @@ static void existsOnLayerFunc( LIBEVAL::CONTEXT* aCtx, void *self )
*/
BOARD* board = item->GetBoard();
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_LayerExpressionCache.find( layerName );
if( i != board->m_LayerExpressionCache.end() )
return ( item->GetLayerSet() & i->second ).any() ? 1.0 : 0.0;
}
LSET mask;
if( i == board->m_LayerExpressionCache.end() )
{
for( unsigned ii = 0; ii < layerMap.GetCount(); ++ii )
{
wxPGChoiceEntry& entry = layerMap[ ii ];
@ -150,18 +158,13 @@ static void existsOnLayerFunc( LIBEVAL::CONTEXT* aCtx, void *self )
mask.set( ToLAYER_ID( entry.GetValue() ) );
}
board->m_LayerExpressionCache[ layerName ] = mask;
}
else
{
mask = i->second;
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_LayerExpressionCache[ layerName ] = mask;
}
if( ( item->GetLayerSet() & mask ).any() )
return 1.0;
return ( item->GetLayerSet() & mask ).any() ? 1.0 : 0.0;
}
return 0.0;
} );
}
@ -273,10 +276,11 @@ static void intersectsCourtyardFunc( LIBEVAL::CONTEXT* aCtx, void* self )
[&]( FOOTPRINT* fp )
{
PTR_PTR_CACHE_KEY key = { fp, item };
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_IntersectsCourtyardCache.find( key );
if( i != board->m_IntersectsCourtyardCache.end() )
@ -287,7 +291,10 @@ static void intersectsCourtyardFunc( LIBEVAL::CONTEXT* aCtx, void* self )
|| collidesWithCourtyard( item, itemShape, context, fp, B_Cu );
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
board->m_IntersectsCourtyardCache[ key ] = res;
}
return res;
} ) )
@ -333,10 +340,11 @@ static void intersectsFrontCourtyardFunc( LIBEVAL::CONTEXT* aCtx, void* self )
[&]( FOOTPRINT* fp )
{
PTR_PTR_CACHE_KEY key = { fp, item };
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_IntersectsFCourtyardCache.find( key );
if( i != board->m_IntersectsFCourtyardCache.end() )
@ -346,7 +354,10 @@ static void intersectsFrontCourtyardFunc( LIBEVAL::CONTEXT* aCtx, void* self )
bool res = collidesWithCourtyard( item, itemShape, context, fp, F_Cu );
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_IntersectsFCourtyardCache[ key ] = res;
}
return res;
} ) )
@ -392,10 +403,11 @@ static void intersectsBackCourtyardFunc( LIBEVAL::CONTEXT* aCtx, void* self )
[&]( FOOTPRINT* fp )
{
PTR_PTR_CACHE_KEY key = { fp, item };
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_IntersectsBCourtyardCache.find( key );
if( i != board->m_IntersectsBCourtyardCache.end() )
@ -405,7 +417,10 @@ static void intersectsBackCourtyardFunc( LIBEVAL::CONTEXT* aCtx, void* self )
bool res = collidesWithCourtyard( item, itemShape, context, fp, B_Cu );
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_IntersectsBCourtyardCache[ key ] = res;
}
return res;
} ) )
@ -650,7 +665,6 @@ static void intersectsAreaFunc( LIBEVAL::CONTEXT* aCtx, void* self )
return false;
LSET testLayers;
PTR_PTR_LAYER_CACHE_KEY key;
if( aLayer != UNDEFINED_LAYER )
testLayers.set( aLayer );
@ -659,10 +673,11 @@ static void intersectsAreaFunc( LIBEVAL::CONTEXT* aCtx, void* self )
for( PCB_LAYER_ID layer : testLayers.UIOrder() )
{
PTR_PTR_LAYER_CACHE_KEY key = { aArea, item, layer };
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::shared_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
key = { aArea, item, layer };
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_IntersectsAreaCache.find( key );
@ -674,7 +689,7 @@ static void intersectsAreaFunc( LIBEVAL::CONTEXT* aCtx, void* self )
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_IntersectsAreaCache[ key ] = collides;
}
@ -736,11 +751,12 @@ static void enclosedByAreaFunc( LIBEVAL::CONTEXT* aCtx, void* self )
if( !aArea->GetBoundingBox().Intersects( itemBBox ) )
return false;
std::unique_lock<std::shared_mutex> cacheLock( board->m_CachesMutex );
PTR_PTR_LAYER_CACHE_KEY key = { aArea, item, layer };
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto i = board->m_EnclosedByAreaCache.find( key );
if( i != board->m_EnclosedByAreaCache.end() )
@ -767,7 +783,10 @@ static void enclosedByAreaFunc( LIBEVAL::CONTEXT* aCtx, void* self )
}
if( ( item->GetFlags() & ROUTER_TRANSIENT ) == 0 )
{
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
board->m_EnclosedByAreaCache[ key ] = enclosedByArea;
}
return enclosedByArea;
} ) )

32
pcbnew/zone.cpp
View File

@ -345,25 +345,22 @@ const BOX2I ZONE::GetBoundingBox() const
if( const BOARD* board = GetBoard() )
{
std::unordered_map<const ZONE*, BOX2I>& cache = board->m_ZoneBBoxCache;
std::shared_lock<std::shared_mutex> readLock( const_cast<BOARD*>( board )->m_CachesMutex );
auto cacheIter = cache.find( this );
if( cacheIter != cache.end() )
return cacheIter->second;
readLock.unlock();
{
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
// if we get here we need an exclusive lock to cache the entry
std::unique_lock<std::shared_mutex> writeLock( const_cast<BOARD*>( board )->m_CachesMutex );
auto cacheIter = cache.find( this );
// check again for the cached item; it might have been computed meanwhile by another thread
cacheIter = cache.find( this );
if( cacheIter != cache.end() )
return cacheIter->second;
}
BOX2I bbox = m_Poly->BBox();
{
std::unique_lock<std::shared_mutex> writeLock( board->m_CachesMutex );
cache[ this ] = bbox;
}
return bbox;
}
@ -374,18 +371,9 @@ const BOX2I ZONE::GetBoundingBox() const
void ZONE::CacheBoundingBox()
{
BOARD* board = GetBoard();
std::unordered_map<const ZONE*, BOX2I>& cache = board->m_ZoneBBoxCache;
std::shared_lock<std::shared_mutex> readLock( board->m_CachesMutex );
auto cacheIter = cache.find( this );
if( cacheIter == cache.end() ) {
readLock.unlock();
std::unique_lock<std::shared_mutex> writeLock(board->m_CachesMutex);
// check again in case another thread has already calculated the entry while we were waiting for the exclusive lock
if ( cache.count( this ) == 0 )
cache[this] = m_Poly->BBox();
}
// GetBoundingBox() will cache it for us, and there's no sense duplicating the somewhat tricky
// locking code.
GetBoundingBox();
}

Write Preview
Loading…
Cancel
Save