CellRandomAccess unexpectedly loads neighboring cells

[igorpisarev]

Let's say a CellImg is defined with cell size [2,2,2], and we want to iterate from min=[4,4,4] to max=[5,5,5] in this image. This interval covers exactly one cell at grid position [2,2,2].
However, looping over this interval using

Views.iterable(Views.interval(cellImg, cell)).cursor()

unexpectedly leads to loading 3 extra cells:

• the very first one at (0,0,0,..) when the random access is initialized
• the previous cell in the iteration order when the cursor is initialized at the "-1" pixel
• the next cell in the iteration order when the cursor reaches the end of the line

This behavior becomes problematic in a workflow when the cells are read and written concurrently as it subtly introduces race conditions.

I also created an example demonstrating this behavior using N5 as a cell storage backend: https://gist.github.com/igorpisarev/591212a26228e4ac7cb482b0134217a1

[hanslovsky]

Thanks for raising this issue @igorpisarev. I talked to @axtimwalde earlier and he said that he was having a look at the CellRandomAccess. Essentially, a cell should only be loaded as necessary on CellRandomAccess.get() and not on any CellRandomAccess.setPosition() or related methods.

[tischi]

@axtimwalde @tpietzsch

I think I found another place where this hits one quite badly. It is in the StackView class:

		public DefaultRA( final RandomAccessibleInterval< T >[] slices, final Interval interval )
		{
			n = slices[ 0 ].numDimensions() + 1;
			sd = n - 1;
			slice = 0;
			tmpLong = new long[ sd ];
			tmpInt = new int[ sd ];
			sliceAccesses = new RandomAccess[ slices.length ];
			if ( interval == null )
			{
				for ( int i = 0; i < slices.length; ++i )
					sliceAccesses[ i ] = slices[ i ].randomAccess();
			}
			else
			{
				final long[] smin = new long[ sd ];
				final long[] smax = new long[ sd ];
				for ( int d = 0; d < sd; ++d )
				{
					smin[ d ] = interval.min( d );
					smax[ d ] = interval.max( d );
				}
				final Interval sliceInterval = new FinalInterval( smin, smax );
				for ( int i = 0; i < slices.length; ++i )
					sliceAccesses[ i ] = slices[ i ].randomAccess( sliceInterval );
			}
			sliceAccess = sliceAccesses[ slice ];
		}

Just for getting one random access to one slice of the data, below loop "touches" all slices:

for ( int i = 0; i < slices.length; ++i )
	sliceAccesses[ i ] = slices[ i ].randomAccess();

The issue is that with the current implementation of randomAccess() this triggers the cellLoader to load some data such that it loads data from all slices, which can be a real problem if data access is expensive.