Discussion :

[Klaim]

Folly : la bibliothèque C++ open-source de Facebook
Une initiative pour partager les outils utilisés en interne

Herb Sutter, l'expert reconnu du langage C++, encense dans son dernier billet de blog l'initiative de Facebook qui vient tout juste de publier en open-source sa bibliothèque d'utilités : Folly.

Cette bibliothèque contient tout un tas d'algorithmes et de structures utilisés dans le code de Facebook. L'essentiel des fonctionnalités couvre les problèmes de performances ou d'absence d'implémentations trouvés dans les bibliothèques déjà existantes comme Boost ou la bibliothèque standard.

De plus en plus d'entreprises mettent leur code source à disposition de tous et permettent de compléter les fonctionnalités fournies par les bibliothèques C++ disponibles. Certaines ont pour but d'être intégrées dans la bibliothèque standard C++, dans le but de corriger ce qui semble être pour Herb Sutter le problème majeur du C++ : le manque d'outils disponibles de façon standard.

Dépôt GitHub de Folly : https://github.com/facebook/folly.

Et vous :
Que pensez-vous de cette initiative de Facebook ?
Pensez-vous pouvoir utiliser cette bibliothèque dans vos propres projets ?

Sources :

• Billet de Hurb Sutter.
• Annonce de Facebook

[Arzar]

Je viens de jeter en œil aux sources et il y a en effet beaucoup de choses intéressantes. Alors attention, il ne faut pas s'attendre à des bibliothèques de haut niveau genre XML, base de donnée ou réseau. Cela reste avant tout une collection de petits composants d'usage général. La majorité de ces composants sont en fait des structures de données orientées multithreading.

Extrait du readme de Folly :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#### `Arena.h`, `ThreadCachedArena.h`
Simple arena for memory allocation: multiple allocations get freed all
at once. With threaded version.
#### [`AtomicHashMap.h`, `AtomicHashArray.h`](AtomicHashMap.md)
High-performance atomic hash map with almost lock-free operation.
#### [`Benchmark.h`](Benchmark.md)
A small framework for benchmarking code. Client code registers
benchmarks, optionally with an argument that dictates the scale of the
benchmark (iterations, working set size etc). The framework runs
benchmarks (subject to a command-line flag) and produces formatted
output with timing information.
#### `Bits.h`
Various bit manipulation utilities optimized for speed.
#### `Bits.h`
Bit-twiddling functions that wrap the
[ffsl(l)](<a href="http://linux.die.net/man/3/ffsll" target="_blank">http://linux.die.net/man/3/ffsll</a>) primitives in a uniform
interface.
#### `ConcurrentSkipList.h`
An implementation of the structure described in [A Provably Correct
Scalable Concurrent Skip
List](<a href="http://www.cs.tau.ac.il/~shanir/nir-pubs-web/Papers/OPODIS2006-BA.pdf" target="_blank">http://www.cs.tau.ac.il/~shanir/nir-...DIS2006-BA.pdf</a>)
by Herlihy et al.
#### [`Conv.h`](Conv.md)
A variety of data conversion routines (notably to and from string),
optimized for speed and safety.
#### `DiscriminatedPtr.h`
Similar to `boost::variant`, but restricted to pointers only. Uses the
highest-order unused 16 bits in a pointer as discriminator. So
`sizeof(DiscriminatedPtr<int, string, Widget>) == sizeof(void*)`.
#### [`dynamic.h`](Dynamic.md)
Dynamically-typed object, created with JSON objects in mind.
#### `Endian.h`
Endian conversion primitives.
####`Escape.h`
Escapes a string in C style.
####`eventfd.h`
Wrapper around the
[`eventfd`](<a href="http://www.kernel.org/doc/man-pages/online/pages/man2/eventfd.2.html" target="_blank">http://www.kernel.org/doc/man-pages/...eventfd.2.html</a>)
system call.
####[`FBString.h`](FBString.md)
A drop-in implementation of `std::string` with a variety of optimizations.
####[`FBVector.h`](FBVector.md)
A mostly drop-in implementation of `std::vector` with a variety of
optimizations.
####`Foreach.h`
Pseudo-statements (implemented as macros) for iteration.
####[`Format.h`](Format.md)
Python-style formatting utilities.
####[`GroupVarint.h`](GroupVarint.md)
[Group Varint
encoding](<a href="http://www.ir.uwaterloo.ca/book/addenda-06-index-compression.html" target="_blank">http://www.ir.uwaterloo.ca/book/adde...mpression.html</a>)
for 32-bit values.
####`Hash.h`
Various popular hash function implementations.
####[`Histogram.h`](Histogram.md)
A simple class for collecting histogram data.
####`IntrusiveList.h`
Convenience type definitions for using `boost::intrusive_list`.
####`json.h`
JSON serializer and deserializer. Uses `dynamic.h`.
####`Likely.h`
Wrappers around [`__builtin_expect`](<a href="http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html" target="_blank">http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html</a>).
####`Malloc.h`
Memory allocation helpers, particularly when using jemalloc.
####`MapUtil.h`
Helpers for finding items in associative containers (such as
`std::map` and `std::unordered_map`).
####[`PackedSyncPtr.h`](PackedSyncPtr.md)
A highly specialized data structure consisting of a pointer, a 1-bit
spin lock, and a 15-bit integral, all inside one 64-bit word.
####`Preprocessor.h`
Necessarily evil stuff.
####`PrettyPrint.h`
Pretty-printer for numbers that appends suffixes of unit used: bytes
(kb, MB, ...), metric suffixes (k, M, G, ...), and time (s, ms, us,
ns, ...).
####[`ProducerConsumerQueue.h`](ProducerConsumerQueue.md)
Lock free single-reader, single-writer queue.
####`Random.h`
Defines only one function---`randomNumberSeed()`.
####`Range.h`
Boost-style range facility and the `StringPiece` specialization.
####`RWSpinLock.h`
Fast and compact reader-writer spin lock.
####`ScopeGuard.h`
C++11 incarnation of the old [ScopeGuard](<a href="http://drdobbs.com/184403758" target="_blank">http://drdobbs.com/184403758</a>) idiom.
####[`SmallLocks.h`](SmallLocks.md)
Very small spin locks (1 byte and 1 bit).
####`small_vector.h`
Vector with the small buffer optimization and an ptional embedded
`PicoSpinLock`.
####`sorted_vector_types.h`
Collections similar to `std::map` but implemented as sorted vectors.
####`StlAllocator.h`
STL allocator wrapping a simple allocate/deallocate interface.
####`String.h`
String utilities that connect `folly::fbstring` with `std::string`.
####[`Synchronized.h`](Synchronized.md)
High-level synchronization library.
####`System.h`
Demangling and errno utilities.
####[`ThreadCachedInt.h`](ThreadCachedInt.md)
High-performance atomic increment using thread caching.
####[`ThreadLocal.h`](ThreadLocal.md)
Improved thread local storage for non-trivial types.
####`TimeoutQueue.h`
Queue with per-item timeout.
####`Traits.h`
Type traits that complement those defined in the standard C++11 header
`<traits>`.
####`Unicode.h`
Defines the `codePointToUtf8` function.

Petite remarque, à la lecture du code j'ai été très étonné de voir que Folly propose du C++ résolument moderne.

Par comparaison, tous les autres gros projets open source (de ma connaissance) en C++ et suffisamment massifs pour avoir eux aussi ce genre de brique de base bien fournies (par exemple llvm/clang ou chromium) ont des contraintes fortes forçant une approche assez conservative, du genre :
- Pas d'exception
- C++03 uniquement, souvent en bannissant certains aspects du langage pour être accepté par le plus grand nombre de compilateurs.
- Pas de bibliothèque tierce.

Du coup c'est assez fascinant de voir que Folly, qui si je comprends bien est la brique de base sur laquelle s’appuie tout le reste du code C++ chez Facebook, au contraire :
- Utilise les exceptions.
- Utilise extensivement le C++11. Il faut d'ailleurs au minimum gcc 4.6 pour compiler le code, vu l'utilisation régulière de feature comme les variadic template ou rvalue reference.
- Utilise extensivement boost.

[Errata]

Du coup c'est assez fascinant de voir que Folly, qui si je comprends bien est la brique de base sur laquelle s’appuie tout le reste du code C++ chez Facebook

Le code a la marque d'Andrei Alexandrescu, qui est le guru C++ chez facebook.
Un code de qualité, dont certain bout de code mériterais d’être envisager pour s’intégrer dans la lib standard (je pense au JSON serializer/deserializer, et aux container thread-safe, fonction de hash).

[David_g]

Je me demande si HipHop peut utiliser aussi cette bibliothèque.

[mitkl]

Je me demande si HipHop peut utiliser aussi cette bibliothèque.

As engineers here, we use, contribute to, and release a lot of open source software, including pieces of our core infrastructure such as HipHop and Thrift.

[Luc Hermitte]

Vous êtes tombés sur des exemples d'utilisation des exceptions ? Car dans le README il est écrit que non.

[Klaim]

J'allais le dire: dans le readme du dossier principal il est ecrit en gros qu'il est interdit d'utiliser les exceptions. Peut être que ca a changé et que ce n'est plus d'actuallité....ou alors yen a qui n'ont pas suivi les regles...

[Arzar]

Oui c'est vraiment curieux ce désaccord dans Folly entre doc et code.
Le code actuel utilise assez régulièrement les exceptions. On en trouve parfois jusque dans les briques vraiment basique comme fbvector et small_vector (std::out_of_range, std::length_error, std::bad_alloc etc.). Il y a aussi régulièrement des commentaires indiquant le degré d'exception safety de certaines fonctions. Autre exemple, la biliothèque json qui utilise systématiquement les exceptions pour remonter les erreurs de parsing (std::runtime_error(to<std::string>("json parse error on line ", line))

Klaim :
Pour ta réponse sur stackoverflow, un autre exemple célèbre de compagnie bannissant les exceptions en bloc pour la totalité de leur code C++ : google
http://google-styleguide.googlecode....xml#Exceptions
(intéressant car contient de nombreuses justifications)