The previews are generated on the fly, and are not stored.
When viewing data on the Submissions pages, keep in mind that you are
making a heavy demand on the server because it needs to access and resize
100 images per page, by default (or more, if you have several images per
submission, or if you increased the submissions-per-page value). AppEngine
will "spin up" extra instances of your application to handle this load, and
will queue requests to those instances so that it handles only a few at a
time (it is unclear how many requests are handled simultaneously). I've
seen it take up to 30 seconds to "spin up" an extra instance, so that will
add an initial delay to the rendering of these images. However, once you
have spun up a sufficient number of instances to handle the image
rendering, the image rendering when paging to the next set of submission
results should be much faster.
Within the server, the next concern is the housekeeping the server needs to
do as it reads these 1.5MB images, resizes them, and sends the smaller
thumbnail to your browser. This housekeeping is called "garbage
collection" and that occurs whenever the server has written data on the
majority of memory under its control. The greater the memory available, the
less frequent the garbage collection. On AppEngine, there is now a setting
to pick the CPU speed and memory size of your server via the Frontend
Instance Class -- go to your dashboard via https://appengine.google.com/ ,
click on your application id, click on Application Settings, then under
Performance, you will see "Frontend Instance Class" and a drop-down list.
Experiment with changing this to a faster and bigger instance. I haven't
played around with this, and without knowledge of how many simultaneous
requests Google allows the server to handle, I can't say whether you would
see a significant change in performance. Again, though, this will only
have an impact after AppEngine has "spun up" as many instances as it deems
necessary to handle the requests triggered when advancing through the
submissions pages; the "spinning up" time will still be a major factor in
Other things to consider:
(1) client computer with more memory or faster CPU. You should compare
access times among a range of client computers (and even the browser on
your Android cell phones). It can give you an idea of how much the speed
and main memory sizes of those computers affect the rendering time of the
images. Also try different browsers.
(2) faster internet connection. If your internet connection is DSL
(256kb/sec) or satellite, or an older/slower Ethernet or WiFi connection,
this may be what is causing the slow response time for the larger images.
It can also impact the rendering of all the images on a single
100-submissions page, as that has 100 x 1.6kB = 160kB * 8b/B = 1.28Mb of
data. For DSL, this would mean 4 seconds minimum to complete the rendering
of the page.
(3) it could be a transient slow-down in the Google infrastructure, which
you can monitor here: http://code.google.com/status/appengine e.g., Java
response times are reported to be "elevated" right now.
On Wed, May 30, 2012 at 7:13 AM, GoranT email@example.com wrote:
I am working with ODK Open Data Kit where i insert some big images.
Every image is about 1,5 MByte.
Accessing and displaying in the browser or any other application takes
There are also previews- when saved to hdd about 1,6 Kbyte: add
But accessing that 1,6Kbyte preview takes also some seconds.
Is that preview image a real "small" image from the original picture
or is it just the big picture scaled down?
Why does it take the same time to access the small preview and the
original big picture?
Is there any way to access the preview image faster?
University of Washington