Git

About - Small and Fast

  1. Branching and Merging
  2. Small and Fast
  3. Distributed
  4. Data Assurance
  5. Staging Area
  6. Free and Open Source
  7. Trademark

Small and Fast

Git is fast. With Git, nearly all operations are performed locally, giving it a huge speed advantage on centralized systems that constantly have to communicate with a server somewhere.

Git was built to work on the Linux kernel, meaning that it has had to effectively handle large repositories from day one. Git is written in C, reducing the overhead of runtimes associated with higher-level languages. Speed and performance has been a primary design goal of Git from the start.

Benchmarks

Let's see how common operations stack up against Subversion, a common centralized version control system that is similar to CVS or Perforce. Smaller is faster.

Commit A
git
svn
Commit B
git
svn
Diff Curr
git
svn
Diff Rec
git
svn
Diff Tags
git
svn
Clone
git*
git
Log (50)
git
svn
Log (All)
git
svn
Log (File)
git
svn
Update
git
svn
Blame
git
svn
Size
git
svn

For testing, large AWS instances were set up in the same availability zone. Git and SVN were installed on both machines, the Ruby repository was copied to both Git and SVN servers, and common operations were performed on both.

In some cases, the commands don't match up exactly. Here, matching on the lowest common denominator was attempted. For example, the 'commit' tests also include the time to push for Git, though most of the time you would not actually be pushing to the server immediately after a commit where the two commands cannot be separated in SVN.

All of these times are in seconds.

Operation Git SVN
Commit Files (A)Add, commit and push 113 modified files (2164+, 2259-)0.642.604x
Commit Images (B)Add, commit and push a thousand 1 kB images1.5324.7016x
Diff CurrentDiff 187 changed files (1664+, 4859-) against last commit0.251.094x
Diff RecentDiff against 4 commits back (269 changed/3609+,6898-)0.253.9916x
Diff TagsDiff two tags against each other (v1.9.1.0/v1.9.3.0)1.1783.5771x
Log (50)Log of the last 50 commits (19 kB of output)0.010.3831x
Log (All)Log of all commits (26,056 commits – 9.4 MB of output)0.52169.20325x
Log (File)Log of the history of a single file (array.c – 483 revs)0.6082.84138x
UpdatePull of Commit A scenario (113 files changed, 2164+, 2259-)0.902.823x
BlameLine annotation of a single file (array.c)1.913.041x

Note that this is the best case scenario for SVN—a server with no load with a gigabit connection to the client machine. Nearly all of these times would be even worse for SVN if that connection was slower, while many of the Git times would not be affected.

Clearly, in many of these common version control operations, Git is one or two orders of magnitude faster than SVN, even under ideal conditions for SVN.

One place where Git is slower is in the initial clone operation. Here, Git is downloading the entire history rather than only the latest version. As seen in the above charts, it's not considerably slower for an operation that is only performed once.

Operation Git* Git SVN
CloneClone and shallow clone(*) in Git vs checkout in SVN21.0107.514.0
Size (MB)Size of total client side data and files after clone/checkout (in MB)181.0132.0

It's also interesting to note that the size of the data on the client side is very similar even though Git also has every version of every file for the entire history of the project. This illustrates how efficient it is at compressing and storing data on the client side.

scroll-to-top