[loading] Try to make network reduction more stable

Always delete the data from within the loop and clear
lists to avoid running into memory allocation issues

[mirror] Do not append \n in get_file.py

Use the write method and check for none to avoid
adding a newline at the end of the file.

[mirror] Add utility to write content + url to disk

Write the URL in the first line and the content
following this.

[mirror] Add a put_file.py to update the data

In the future this script might update the Content-Length
and such information. But this is not strictly necessary
as the current server is ignoring all such information.

[mirror] Add a utilitiy to get the content of a given file

Be able to extract one file from the content.

[mirror] Add list_files.py to list the content of the db

[mirror] Fix the create_hosts script to remove a possible port from the URL

Look for a ':' and then remove everything starting from it.. This
is filtering a site like:
    ads.guardian.co.uk:80

[time] Add a reduction to compare different currentTime implementations

Currently this compares gettimeofday to clock_gettime and the
current winner is gettimeofday...

Disable the pagecache/cache to get more stable loading results

To generate a stable result on the cycler and loading test disabling
the cache is necessary. Together with the -media 5 option of the
test case the result is quite stable.

memusagestat.c: Merge with upstream glibc

memusagestat: Cope with slightly broken files

Continue even when having a slightly broken file.

memusagestat.c: Some fixes to memusagestat

- Spelling fix
- After fixing the header start to parse again otherwise
  wrong values are used
- For many allocations use uint64_t

Change cycler/loading to benchmark running through all sites

Attempt to get more stable performance numbers by running through
every site and benchmarking this. Before some tests were so fast
mostly depending on host scheduling and yielding different results
each run.

Ignore some more generated files

image_loading/image_cycling: Share the WebCore classes

Share the WebCore classes between the two tests. These can
be easily replaced with the WebCore original after changes
to WebCore. Currently this copy is ahead of WebCore but
this will change in a second.

reductions: Add missing files

ImageDecoder: Change to go through the factory

Add two reductions for image loading

Extract webcore code to analyze the behaviour on the
loading and cycling test.

You will need to ask me for the data used for this test
as this is copyrighted material and can not be freely
published.

Fix building after the moving of the files

http_server: Proper fix for the socket close during header parse..

The previous fix was obviously wrong. Break the outer loop to
interrupt the parsing when the connection is gone. There is not
much use continuing but there is not really a harm anyway.

Move tools into host-tools|reductions|tests

Split the tools in three categories:
    tests      For benchmarks and tests
    host-tools For tools to be executed on the host
    reductions Test cases extracted from WebKit/Qt

README: Make it refer to the Wiki pages

http_server: Stop trying to read when we are disconnected...

canReadLine returns true even if we are disconnected, check
the connection state and exit... e.g. when the network job
has been canceled..

Add a new test called cycler...

The cycler test is close to the loading test but it will
show the webview and will do painting. This can be used
for cyclic loading of webpages with a high iteration count
and will be nice for memory usage analysis.

common: Add additional test case with many images

The images on the site are desktop images for the mac, the
creator of the site must have been obsessed by unerotic
and plain nudity of females... This does not include porn
and I wish we would have other images... besides that it
is a great test for image decoders.

loading_standalone: Make the code compile without a patched Qt

Disable the "faster" code path as the patch is not yet
included in Qt. Enable it once it has landed in Qt4.6
or Qt4.7.

Install target utilities to QT_INSTALL_BINS/benchmark

with make INSTALL_ROOT=$PWD/root install the utilities can
be installed and then copied to the device.

loading_standalone: Rename the target and pro file

Do not clash with the normal loading test case

http_server: Using a QCoreApplication is enough in the server

http_server: No need to test the database code anymore

benchmarks: Remove memusagestat from the compile list

mirror: Use optparse in create_hosts...

Allow to specify the to be used database on the command line.

loading_standalone: Fix indenting of the code path

Add the standalone unit test as well

http_server: Compile fix on ARM...

Close is not known, include unistd.h to fix that.

http_server.pro: Add missing file

painting: Use QApplication::syncX at the end of painting..

Do not only measure how fast we can send painting instructions
but also sort of wait until it is done. The main point of this
test is to highlight areas were to improve.

loading_standalone: Put the date parsing under trial

Test the QNetworkHeadersPrivate::fromHttpDate date parsing
code and compare it with a more direct solution. The more
direct solution is 10 times faster than the old one.

http_server: Plug leak in the error case...

This code was not executed so no real life leak was plugged...

loading_standalone: Have a simple benchmark for QByteArray::operator==

Compare toLower + operator== with qstricmp... on my desktop
qstricmp is winning over toLower + operator== and QNetwork
code will be changed to follow that.

loading_standalone: Use a new QNetwork method...

Do not have a O(n^2) runtime behaviour to copy headers
from QNetworkReply to WebCore...

loading_standalone: Add latency and download time measurement

Use clock_gettime to get a monotonic tick. Measure how long it
takes to get the didReceiveResponse and how long it takes to
finish the download.

loading_standalone: Turn the loading into a QBENCHMARK

loading_standalone: Mention the leaks...

These are leaked but as long as the number of iterations are
small enough it should not be a big problem...

loading_standalone: Minor cleanup...

loading_standalone: Isolated test for loading wikipedia

This contains the wikipedia maxwell equation article. The
page itself is inside the wikipedia_maxwell.db and can be
served using the fake http_server.
This test will purely measure the networking performance
of the QNetworkAccessManager without taking parsing, etc.
into account. This will allow to more easily look into
the networking classes.

This test contains code from QtWebKit to make the test
match Qt as closely as possible. Future extensions should
have better time keeping which should include latency
and download statistics.

Optimations should include:
    - raw speed
    - scheduling performance...

mirror: Generate cookies... only works with a recent 4.6

WIP

mirror: Update the google news entry with a working one

mirror: Remove some debugging warnings again

Remove some log messages...

mirror/http_server: Generate the header in the mirror tool

Generate the header in the mirror tool, make sure it has \r\n
at the end of lines (fixes various redirect issues), make sure
to strip transfer-encoding (as we don't do chunked...), add
a fake content-length entry..

Currently strip cookies away as emitting all cookies in one
line is not legal and we need to split them up.

mirror: Do not properly destruct objects...

Proper destruction will emit shared timers, and other bits...
e.g. in the worse case start a network job after the CookieJar
was destructed...

memusagestat: Give the graph a grey background...

improve readability in tools like eog.

memusagestat: make it compile

memusagestat: Add glibc's memusagestat.c

Add cli utility to deal with memusage data. We add a copy here
as it is normally not installed by any distribution.

scrolling: Show the QWidget to make sure paint events get generated

If the window is not visible, nothing will be painted...

scrolling: Scroll in the backward direction as well

scrolling: Add benchmark to scroll as fast as possible

This test is painting on the QWidget and will scroll
the content to the bottom. This requires to enter the
event loop...

mirror: Rewrite the create_hosts script...

Change the script from shell to python to cope with
the encoded output of the url data. Use the most simple
approach to create the output file.

benchmarks: Add common file to add benchmark data...

mirror: Add help screen

mirror: add option to be visible

mirror/http: Store URL in encoded form..

Store thr URL in the network encoded form. This should fix
cases of URLs containing space and other bits..

http_server: Search for URL without fragment and query

If the normal query failed, search for a URL without the
query and fragment and serve that.

mirror: Strip fragments and query from the url

E.g. for the sunspider-result.html strip out the query and
fragment page to have a generic version that will work with
any data...

mirror: Refactor storing of the data

Move the SQL code into a new static function. Pass this
function the data. This will be useful when we start to
strip the query part from the url and store the url
twice...

mirror: Add the -k option to keep running, refactor config parsing

mirror: Spelling fix...

http_server: Wait for being disconnected before destroying the socket

Make sure everything is flushed and tranfered to the client before
closing the connection. This makes running the sunspider suite
possible with the cached webserver.

mirror: Replace the "observer" with a "proxy"

For some content the observer did not work reliable. Turn
the code into a real proxy that is forwarding signals and
data from the QNetworkReply to the new front. When reading
we are able to properly access the data and store it
somewhere else.

mirror: Fix the do_mirror.sh script to pass the arguments on to mirror

http-server: Use QSql database prepare as well..

I have no idea how this worked before...

mirror: DB code fixes... use QSqlQuery::prepare, only exec once

Change the URL toString for storing it in the db, change the db
code to use prepare and exec, exec only once... it seems to work
again.

Implement a cookie jar...

This is extremly useful to use accounts with sites that remember
the user. The cookie file can be taken from arora and passed on
with the -c option.

Pass on arguments to the mirror application

We will be able to load cookies in a second.

Some more from the top 50 of alexa.com... and some handpicks

mirror: Add more websites... some more from the top 50..

Fixes for wget... wget is only http 1.0

http_server: Replace the python webserver with a Qt one

The BasicHTTPServer loves to get stuck, probably specially
by keep-alive (it doesn't advertise to do HTTP/1.1...). Replace
it with a custom multi threaded solution...

The multithreaded solution should use a fixed number of worker
threads instead of creating as many as possible.

http_server: Handle the response code we get

mirror: Wait for everything to be loaded before exiting

The last chnage was not really sound, load everything...

mirror: Update some sitrs...

mirror: Do not use app::quit as this will make flash cause a segfault

mirror: Fix storing the data...

mirror: Fix compile

Explain what these tools are for.

benchmarks.pro: Add the launcher test to the list

http_server: Do not advertise gzip encoding when not using it

firefox, Qt doesn't like that, libsoup handles it just fine.

painting: Remove the scrolling for now

In general we can not tell where more text is. The test
case should be changed to automatically scroll the page
in both directions.

mirror: Save the response as well as we need that information in the server

launcher: Add a simple launcher app to open pages

e.g. this can be used to run the sunspider benchmark

hosts: List entries for /etc/hosts from a database

Add a http server to serve the static content.

based off an example using the python BasicHTTPServer.

mirror: Add a simple mirroring application

This will mirror a webpage into a sqlite3 database. This database
can be used to serve a webpage again. This way we can create
stable pages for page loading test.

do_mirror.sh contains some frequently visited pages we should
optimize for.

robustness: Be able to set a start page

Add a bunch of performance/reliable tests for QtWebKit

loaing: test loading of a bunch of pages
painting: test painting of a bunch of pages
robustness: crawl the web and wait for crashes