Add more dataset size information

README.md

@@ -39,15 +39,37 @@ task_ids: []
 
 |Release|Programming Languages|Description|
 |-|-|-|
-|v1.0| C/C++, Rust, Swift, Julia | Fine Tuning-scale dataset of 564GB of deduplicated LLVM IR |
+|v1.0| C/C++, Rust, Swift, Julia | Fine Tuning-scale dataset of 602GB of deduplicated LLVM (bitcode) IR |
 
 ### Dataset Summary
 
-ComPile contains over 500GB of permissively-licensed source code compiled to [LLVM](https://llvm.org) intermediate representation (IR) covering C/C++, Rust, Swift, and Julia.
+ComPile contains over 2.7TB of permissively-licensed source code compiled to (textual) [LLVM](https://llvm.org)
+intermediate representation (IR) covering C/C++, Rust, Swift, and Julia.
 The dataset was created by hooking into LLVM code generation either through the language's package manager or the
 compiler directly to extract the dataset of intermediate representations from production grade programs using our
 [dataset collection utility for the LLVM compilation infrastructure](https://doi.org/10.5281/zenodo.10155761).
 
+### Dataset Size
+
+The public release of ComPile contains over 2.7TB of textual LLVM-IR, which tokenizes into 1.3+T tokens using the Llama
+tokenizer.
+
+| Langauage | Bitcode Size | Textual IR Size | Llama Token Count | BPE Token Count (10k Vocab) | BPE Token Count (50k Vocab) |
+|-----------|--------------|-----------------|-------------------|-----------------------------|-----------------------------|
+| C         | 2.47GB       | 10.19GB         | 5.31B             | 0.91B                       | 0.58B                       |
+| C++       | 28.87GB      | 102.76GB        | 46.75B            | 11.20B                      | 6.27B                       |
+| Julia     | 164.16GB     | 1088.39GB       | 547.60B           | 41.91B                      | 23.49B                      |
+| Rust      | 399.94GB     | 1523.84GB       | 735.90B           | 137.37B                     | 90.01B                      |
+| Swift     | 6.95GB       | 35.93GB         | 19.78B            | 3.36B                       | 1.75B                       |
+| Total     | 602.39GB     | 2761.11GB       | 1355.34B          | 194.75B                     | 122.10B                     |
+
+ComPile is distributed as bitcode, which is a compressed format that can be easily converted to and from the
+textual representation of LLVM-IR. To collect token counts, we disassembled the bitcode to convert it into textual
+IR and then ran a tokenizer over it. We used the standard Llama tokenizer and then ran fastBPE using a custom
+vocabulary trained on a multi-GB sample of textual IR representativie of all languages in ComPile at two different
+two different vocab sizes, particularly 10k and 50k. LLVM-IR is quite formulaic, so using custom vocabulary significantly
+reduces the number of tokens generated.
+
 ### Languages
 
 The dataset contains **5 programming languages** as of v1.0.
@@ -119,17 +141,17 @@ typically a link to a tar archive or git repository from which the project was b
 mapping to a specific package ecosystem that provides the source, such as Spack.
 - `language` (string): This column indicates the source language that the module was compiled from.
 
-## Dataset Size
+## License Constraints and Deduplication
 
 | Langauge | Raw Size | License Constraints | Deduplicated + License Constraints |
 |----------|----------|---------------------|------------------------------------|
-| C/C++    | 124GB    | 47GB                | 31GB                               |
-| C        | N/A      | N/A                 | 3GB                                |
-| C++      | N/A      | N/A                 | 28GB                               |
-| Julia    | 201GB    | 179GB               | 153GB                              |
+| C/C++    | 126GB    | 46GB                | 31GB                               |
+| C        | 16GB     | N/A                 | 2GB                                |
+| C++      | 109GB    | N/A                 | 29GB                               |
+| Julia    | 201GB    | 179GB               | 164GB                              |
 | Swift    | 8GB      | 7GB                 | 7GB                                |
-| Rust     | 656GB    | 443GB               | 373GB                              |
-| Total    | 989GB    | 676GB               | 564GB                              |
+| Rust     | 656GB    | 443GB               | 400GB                              |
+| Total    | 990GB    | 675GB               | 602GB                              |
 
 The raw size is the size obtained directly from building all the projects. The license constraints column
 shows the size per language after license information is taken into account. The last column shows the size
@@ -138,7 +160,8 @@ dataset.
 
 Note that the sizes displayed here are of the compressed bitcode representation rather
 than textual IR. We see an expansion ratio of 2-5x, averaging around 4x when converting
-from compressed bitcode to textual IR.
+from compressed bitcode to textual IR. Specific per-language numbers are available in the section
+above on dataset size.
 
 ## Dataset Construction