Data

Data: How to surf, rather than drown!

=Introduction=

=Data on Disk=

A Salutary Tale of Copying Files
We'll start by considering data stored on a disk drive. One thing that you might not know is that file systems and disk drives perform best when they are dealing with larger files. But how large is large? Here's a simple example, which you can try yourself:

First of all, let's get ourselves a large-ish file. A compressed tarball of the source code for the Linux kernel will do. In this case it's about 70MB in size. We can time how long it takes to create a copy of it. Below are the results of doing this experiment on BlueCrystal phase 2:

BCp2$ wget https://www.kernel.org/pub/linux/kernel/v3.x/testing/linux-3.10-rc7.tar.xz BCp2$ time cp linux-3.10-rc7.tar.xz linux-3.10-rc7.tar.xz.copy

real	0m3.530s user	0m0.000s sys	0m0.068s

Now, that tar ball contains around 47,000 files, many of which are only a few hundred or thousand of bytes in size. These are files at the smaller end of the scale. Let's unpack the tarball and time how long it takes to copy these files, one-by-one:

BCp2$ tar --use-compress-program=xz -xf linux-3.10-rc7.tar.xz BCp2$ time cp -r linux-3.10-rc7 linux-3.10-rc7.copy

real	18m17.102s user	0m0.214s sys	0m6.359s

Yikes! that took over 350 times longer than copying the single, large file. (These timings were taken at ~10:45 on the 25 Jun 2013. Any differences from the above values will be due to differences in load on the filesystem, which is shared with all the other users of the cluster.  More of that in a moment..)

Now, we can repeat these tests on a different system. I got the values below from my very standard desktop machine:

desktop$ wget https://www.kernel.org/pub/linux/kernel/v3.x/testing/linux-3.10-rc7.tar.xz desktop$ time cp linux-3.10-rc7.tar.xz linux-3.10-rc7.tar.xz.copy

real	0m0.192s user	0m0.000s sys	0m0.156s

desktop$ tar --use-compress-program=xz -xf linux-3.10-rc7.tar.xz desktop$ time cp -r linux-3.10-rc7 linux-3.10-rc7.copy

real	0m25.961s user	0m0.168s sys	0m2.360s

That's a lot quicker! However, copying the small files still took over 130 times longer than copying the large file. (Again, your mileage may vary.)

But hang on, I thought BlueCrystal was meant to be "super"?! Well it is. It's just that it's filesystem is servicing much more than just your file copying request.

Modern SATA disks have read and write bandwidths close to 100MB/s--for example, I just tested my Linux desktop machine with a handy, built-in utility (System > Administration > Disk utility) and recorded a read performance of ~75MB/s. We can compare this to the filesystem on BlueCrystal phase 2, where we see a peak of about 500MB/s throughput on the mixed workload of full, running cluster.

Another test below highlights a key difference between a parallel filesystem and that on a single disk. If I start several processes writing to the disk in my desktop machine, I see a rapid drop-off in performance as the number of processes increases. In contrast the parallel filesystem is able to support many processes with modest degradation to file writing performance.

So what have we learned?


 * You'll get better file access performance if you use larger rather than smaller files.
 * If you are using BlueCrystal, you may want to consider using disks local to the compute nodes. These nodes are 300GB in size and are accessible via /local.  If you do elect to use local disks:
 * It is advisable to check the available space in /local as part of your job.
 * Please do clean up /local after your job has finished
 * when transferring data from node to node, please use the suffix .data.cluster when referring to a node, e.g. scp u04n037.data.cluster:/local/mydata $HOME.

Additionally (and not demonstrated above):
 * Make use of minimal seek operations, which implies
 * Make use of contiguous access patterns, rather than random ones.

=Data over the Network=

Filling the pipe.

=Data when Writing your own Code=

Locality of Reference: http://en.wikipedia.org/wiki/Locality_of_reference

Temporal locality: We expect to re-use of data already seen. Spatial locality: We expect to access data stored close to data that we've already seen.

Computer hardware is optimised to exploit these principles. We will get the most from our hardware if we design software accordingly.

Files & File Formats
=Data Analytics=

Some common operations you may want to perform on your data:


 * Cleaning
 * Filtering
 * Calculating summary statics (means, medians, variances)
 * Creating plots & graphics
 * Tests of statistical significance
 * Sorting and searching

Selecting the right tools.

SQLite
A very popular relational database. Lightweight as it is unmanaged and so has very simple access controls. However does support SQL. The command line interface is widely available. For example, it is installed on BlueCrystal.

Let's start up the command line interface:

sqlite3 test.db

In this case, we've specified the file test.db. If the file exists, it will open it. Else it will create a new database to be stored in the given file.

Without further ado, let's create a table in given database and populate it with some records:

Now, let's see the fruits of our labours. After setting some formatting information, we can use an SQL command to select all the records in the planets table:

Id         Name        Diameter    Mass        Orbital_Period -- --  --  --  -- 1           Mercury     0.382       0.06        0.24 2          Venus       0.949       0.82        0.72 3          Earth       1.0         1.0         1.0 4          Mars        0.532       0.11        1.52 5          Jupiter     11.209      317.8       5.2 6          Saturn      9.449       95.2        9.54 7          Uranus      4.007       14.6        19.22 8          Neptune     3.883       17.2        30.06

We can also issue a more exacting query. In this case, let's ask for all the planets which have a mass greater than or equal to that of the Earth:

Id         Name        Diameter    Mass        Orbital_Period -- --  --  --  -- 3           Earth       1.0         1.0         1.0 5          Jupiter     11.209      317.8       5.2 6          Saturn      9.449       95.2        9.54 7          Uranus      4.007       14.6        19.22 8          Neptune     3.883       17.2        30.06

So far so good. Let's create an additional table called moons:

Now that we have two tables, we can examine the very powerful feature of JOINing tables, common to all good relational databases. A, so called, natural inner join will create a new table, on-the-fly, from all the records in the joined tables which have matching values:

Name       Orbital_Period  Num_Moons -- --  -- Mercury     0.24            0 Venus      0.72            0 Earth      1.0             1 Mars       1.52            2 Jupiter    5.2             67 Saturn     9.54            62 Uranus     19.22           27 Neptune    30.06           13

Note that Pluto was not listed as a result of the inner join, since it is not present in the planets table.

We can also create an outer join, which is not so constrained. SQLite does not, as yet, support a 'right outer join' and so I needed to swap the order of the tables in the join so that my 'left outer join' contained all those in the left table (i.e. the table containing the name Pluto).

Notice that Pluto record is blank in the Orbital_Period column as there is no corresponding value in the planets table.

Name       Orbital_Period  Num_Moons -- --  -- Mercury     0.24            0 Venus      0.72            0 Earth      1.0             1 Mars       1.52            2 Jupiter    5.2             67 Saturn     9.54            62 Uranus     19.22           27 Neptune    30.06           13 Pluto                      5

If you would like to export to, e.g., a CSV file (this is useful for subsequent import into, e.g., R):

Where the contents of the file planets.csv is:

Id,Name,Diameter,Mass,Orbital 3,Earth,1.0,1.0,1.0 5,Jupiter,11.209,317.8,5.2 6,Saturn,9.449,95.2,9.54 7,Uranus,4.007,14.6,19.22 8,Neptune,3.883,17.2,30.06

There is, of course a corresponding command to import data from a file into a table. For example, if I had information about stars in an appropriately formatted CSV files, I could load it into a table called stars using the commands:

To exit the SQLite command line interpreter type:

It is perfectly possible--indeed, perhaps preferable--to access a database from inside a program. (SQLite was really designed with that in mind.) For example, you can learn more about accessing an SQLite database from inside a python script at:


 * https://source.ggy.bris.ac.uk/wiki/Python1#Relational_Databases Relational

More information about SQLite and other interfaces for access is at:


 * SQLite: e.g. http://zetcode.com/db/sqlite/

MySQL
Taking a step up on the functionality ladder, MySQL is a popular, open-source, enterprise grade relational database management system (RDMS), which is readily available for most operating systems. In the notes below, I will assume that you have MySQL installed and have set a password for the root user. For popular Linux distributions, such as Ubuntu and CentOS, MySQL is easily installed through the package manager. (More information on MySQL installation.)

OK, our first tasks will be to connect to the MySQL monitor tool as the administrator, and to create new users and databases:

gethin@gethin-desktop:~$ mysql -u root -p Enter password:

After typing the administrator password we are greeted with:

Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 36 Server version: 5.1.69-0ubuntu0.10.04.1 (Ubuntu)

Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its affiliates. Other names may be trademarks of their respective owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement. mysql>

Let's create a user. Note that the password, changeme in this case, is in clear text.

A database, called menagerie, to practice with:

And we'll grant some privileges (in this case ALL--a full set of privileges) for all the tables to be stored in the menagerie database to the user called gethin:

Now, to work on that database, we want to disconnect as the administrator and connect as an appropriate user:

switch to the database in question:

and create a new table:

Now, if we had a CSV file of the form:

1,'Mercury',0.382,0.06,0.24 2,'Venus',0.949,0.82,0.72 3,'Earth',1.0,1.0,1.0 4,'Mars',0.532,0.11,1.52 5,'Jupiter',11.209,317.8,5.20 6,'Saturn',9.449,95.2,9.54 7,'Uranus',4.007,14.6,19.22 8,'Neptune',3.883,17.2,30.06

we could load this directly into our planets table, without the labourious SQL INSERT commands:

et voila, we can see the data duly loaded into the table:

UoB Data Haven
GUI. Accessing from a program or script. Enterprise Grade The data haven.

Numerical Packages
Such as R, MATLAB & Python.

Rolling Your Own
Principles: Sort & binary search.

Tools: Languages, libraries and packages.

=When Data gets Big=

Quotas.

Local Disks.

Swapping.

Data the Google way - Map-Reduce.

Hadoop & Friends.


 * http://hadoop.apache.org/docs/r0.18.3/streaming.html

=Summary=


 * Use large files whenever possible.
 * Disks are poor at servicing a large number of seek requests.
 * Check that you're making best use of a computer's memory hierarchy, i.e.:
 * Think about locality of reference.
 * Go to main memory as infrequently as possible.
 * Go to disk as infrequently as possible as possible.
 * Check that your are still using the right tools if your data grows.