A Scalable, User-Friendly Source Control System.
Go to file
Jun Wu 1bd54a5971 dag: drop lifetime on Segment<'a>
Summary:
This allows structures like BTreeMap to own and store Segment.

It was not possible until D19818714, which adds minibytes::Bytes interface for
indexedlog.

In theory this hurts performance a little bit. But the perf difference does not
seem visible by `cargo bench --bench dag_ops`:

  # before
  building segments                                 714.420 ms
  ancestors                                          54.045 ms
  children                                          490.386 ms
  common_ancestors (spans)                            2.579 s
  descendants (small subset)                        406.374 ms
  gca_one (2 ids)                                   161.260 ms
  gca_one (spans)                                     2.731 s
  gca_all (2 ids)                                   287.857 ms
  gca_all (spans)                                     2.799 s
  heads                                             234.130 ms
  heads_ancestors                                    39.383 ms
  is_ancestor                                       113.847 ms
  parents                                           251.604 ms
  parent_ids                                         11.412 ms
  range (2 ids)                                     117.037 ms
  range (spans)                                     241.156 ms
  roots                                             507.328 ms

  # after
  building segments                                 750.129 ms
  ancestors                                          53.341 ms
  children                                          515.607 ms
  common_ancestors (spans)                            2.664 s
  descendants (small subset)                        411.556 ms
  gca_one (2 ids)                                   164.466 ms
  gca_one (spans)                                     2.701 s
  gca_all (2 ids)                                   290.516 ms
  gca_all (spans)                                     2.801 s
  heads                                             240.548 ms
  heads_ancestors                                    39.625 ms
  is_ancestor                                       115.735 ms
  parents                                           239.353 ms
  parent_ids                                         11.172 ms
  range (2 ids)                                     115.483 ms
  range (spans)                                     235.694 ms
  roots                                             506.861 ms

Reviewed By: sfilipco

Differential Revision: D20505201

fbshipit-source-id: c34d48f0216fc5b20a1d348a75ace89ace7c080b
2020-03-18 15:05:57 -07:00
.github/workflows add GitHub workflow for testing scm/lib crates 2020-03-11 12:00:16 -07:00
build Updating submodules 2020-03-18 13:26:02 -07:00
CMake eden: use third-party/rust for the vendored crates 2020-02-07 13:10:52 -08:00
common Factor our hw_port_stats_fb303 lib 2020-02-03 17:37:05 -08:00
eden dag: drop lifetime on Segment<'a> 2020-03-18 15:05:57 -07:00
.gitignore mononoke: add README.md and the missing pieces for supporting cargo (#13) 2020-02-13 00:12:36 -08:00
.travis.yml Re-sync with internal repository 2020-01-17 14:43:45 +01:00
CMakeLists.txt eden: add helper command for working with apfs 2020-02-03 16:59:17 -08:00
CODE_OF_CONDUCT.md mononoke: move the codebase under eden/ directory 2020-02-06 13:46:04 +01:00
CONTRIBUTING.md mononoke: move the codebase under eden/ directory 2020-02-06 13:46:04 +01:00
getdeps.py Tidy up license headers 2019-10-11 05:28:23 -07:00
LICENSE mononoke: move the codebase under eden/ directory 2020-02-06 13:46:04 +01:00
make-client.py eden: use the zipapp_main instead of main so return code gets correctly returned 2019-12-03 09:20:42 -08:00
README.md mononoke: move the codebase under eden/ directory 2020-02-06 13:46:04 +01:00
rustfmt.toml Get rustfmt/rls working in fbcode again. 2019-09-19 18:06:23 -07:00

EdenFS is a FUSE virtual filesystem for source control repositories.

EdenFS speeds up operations in large repositories by only populating working directory files on demand, as they are accessed. This makes operations like checkout much faster, in exchange for a small performance hit when first accessing new files. This is quite beneficial in large repositories where developers often only work with a small subset of the repository at a time.

EdenFS has similar performance advantages to using sparse checkouts, but a much better user experience. Unlike with sparse checkouts, EdenFS does not require manually curating the list of files to check out, and users can transparently access any file without needing to update the profile.

EdenFS also keeps track of which files have been modified, allowing very efficient status queries that do not need to scan the working directory. The filesystem monitoring tool Watchman also integrates with EdenFS, allowing it to more efficiently track updates to the filesystem.

Building EdenFS

EdenFS currently only builds on Linux. We have primarily tested building it on Ubuntu 18.04.

TL;DR

[eden]$ ./getdeps.py --system-deps
[eden]$ mkdir _build && cd _build
[eden/_build]$ cmake ..
[eden/_build]$ make

Dependencies

EdenFS depends on several other third-party projects. Some of these are commonly available as part of most Linux distributions, while others need to be downloaded and built from GitHub.

The getdeps.py script can be used to help download and build EdenFS's dependencies.

Operating System Dependencies

Running getdeps.py with --system-deps will make it install third-party dependencies available from your operating system's package management system. Without this argument it assumes you already have correct OS dependencies installed, and it only updates and builds dependencies that must be compiled from source.

GitHub Dependencies

By default getdeps.py will check out third-party dependencies into the eden/external/ directory, then build and install them into eden/external/install/

If repositories for some of the dependencies are already present in eden/external/ getdeps.py does not automatically fetch the latest upstream changes from GitHub. You can explicitly run ./getdeps.py --update if you want it to fetch the latest updates for each dependency and rebuild them from scratch.

License

See LICENSE.