"SystemAcesssViolation" when generating offscreeen bitmaps

[pathw0rk3r]

This is a follow on from my question #688. I'm happy to report that we have been successful in generating the GRContexts for both UWP and iOS and with it can create surfaces to generate bitmaps which get supplied as a serve to SKXamlCanvas or SKCanvasView controls. I have added comments in #688 about further details to help anyone which is interested in doing the same thing.

The app using the technology generates complex maps, often with thousands of features in a single bitmap. The features are built up in layers and come in as tiles. As tiles arrive, more layers are added to the bitmap, so the generation of the bitmap is like a daisy chain of progressive updates until all the layers have been added in.

Here is the central method:

So each time tiles arrives, a surface gets created, and its canvas is used to update the latest image through the renderActivity method. The latest bitmap then gets sent to the control for rendering. The calls to the Render method happen in a single thread and are sequential. When the control is heavily used, for instance to when the user is doing a series of quick pans and zooms, occasionally a "SystemAccessViolation exception occurs - 'Attempted to read or write protected memory. This is often an indication that other memory is corrupt.'

Adding in the 'surface.Dispose()' call at the end of the method significantly reduces the number of times this occurs.

It seems that something is happening in the snapshotting and bitmap creation which doesn't close things properly.

I also noticed that combining the results of surfaces is most commonly the situation where the exception arises. I keep a bitmap of the features as they get built up and another one for markups. The tiles and the markup information come in at random times, but they are always processed sequentially in the method above. So a features bitmap is being generated and a markup bitmap is being generated. At the end I merge the two bitmaps together. The requests to the method come in via a queue, so I have some sense of what is going on when the exception happens. If there is the last update to the feature bitmap, followed by a quite update to the markups layers(which happens very quickly with its bitmap being mostly empty), it is during the merge processing of just drawing the features bitmap, followed by the markups bitmap that the exception arises. It is like the markups bitmap hasn't closed yet, and I'm trying to render it to a canvas. Is there any way to test if a bitmap is finished? Originally I passed back images to the control instead of bitmaps, but that caused these SystemAccessViolation messages almost continually. Here is the method that merges the bitmaps:

I wonder if it has to do with resources? I create the surfaces simply, without using the constructor that uses budgeting, or sample count. The documentation doesn't really explain what these parameters do or how they should be set. Could it be that the current settings are reusing a buffer somewhere which causes the conflict? I do everything in usings, so I thought this wouldn't be a problem. I also thought that the flush method would finish guarantee that the GPU has all the instructions it needs to generate the updates to the canvas.

In the interim, is there someway to be able to recover from the SystemAcessViolation exception? I'd really prefer not to have to put timers in things to slow everything down. The whole point was to make things go fast using the GPU (and when it works it goes really fast :-))

Any insights would be greatly appreciated,
Tom Cuthill

VS bug #770228

[mattleibow]

Good to hear that you got most of the bits working from #688. With regards to this particular issue, all skia operations are synchronous - this means that when the method returns, it is finished the job.

As you are drawing on the GPU, using bitmaps means that the image data is being copied back and forth between memory and the GPU. You mention that if you use images, you get exceptions all over. Do you have a stack trace of some sort?

I am actually not that sure about the rules about multithreaded, cross-threaded, cross-context drawing, so I asked a question on the skia forums: https://groups.google.com/forum/#!topic/skia-discuss/dj8UJT_tqcU For some reason, I seem to recall that images created with one context can't be used by another - which may be what you are seeing when using images.

With this code, are you using a single context across threads? Are you using multiple contexts at all? (this may be the case if you are creating your own context, but then drawing to a view with that context) If there is multiple threads, is the underlying OpenGLES context able to handle multiple threads? (which again may be the case because you are creating a new context - I know iOS has something called sharegroups.

As for the exception, do you have any stack traces that may give some more information.

[Al3xlab]

To complete the observation of @pathw0rk3r: I copied the code of #688 to create a GRContext on UWP. My SKSurface 'accelerated' is running on a background thread, but the snapshot (SKImage) is empty in the main thread and can not be displayed by SKCanvasView! Similarly, like @pathw0rk3r, I created a SKBitmap from the snapshot, and the pixel array is identical from the backgroung thread to the main thread.
So far, I don't see a SystemAcesssViolation exception, but other problems: when I change the size of the accelerated SKSurface at runtime, the bitmap can no longer be created from the snapshot (become null because the snapshot is corrupt ?). I instantiate and dispose the surface, canvas, image, and bitmap in the background rendering loop.
Another surprise, when my rendering loop is repeated (only 1 FPS), multiple frames are not displayed and I get glitches on the bitmap. Have you seen anything like this before ?

Normal:

Glitches: