### Design
#### Overview
The `clf` library is a Rust crate that provides a simple interface to flush the CPU data cache line. It is designed to be used in benchmarks that are not dependent on the CPU cache. The library implements native data cache flushing for x86_64 and AArch64 and wraps the `__builtin_clear_cache()` function as a fallback for other architectures.
#### Architecture
The library is composed of three main parts:
1. **A Rust library:** This library provides the public API for the `clf` crate. It consists of two functions: `cache_line_flush_with_ptr` and `cache_line_flush_with_slice`. It contains the native implementation for supported architectures.
2. **A C library:** This library provides the fallback implementation of the `_cache_line_flush` function using `__builtin_clear_cache()`.
3. **Build System:** Uses `cc` in `build.rs` to compile the C fallback.
#### Components
* **`lib.rs`:** This file contains the Rust code for the `clf` library. It defines the public API and implements architecture-specific flushing using `core::arch` or `asm!`.
* **`clf.c`:** This file contains the C code for the `_cache_line_flush` function (fallback).
* **`clf-void.c`:** This file contains a stub implementation for unsupported compilers or specific targets.
* **`build.rs`:** Compiles the C fallback and links it.
#### Data Flow
The data flow is as follows:
1. The user calls one of the public functions in the `clf` library.
2. On **x86_64**: The library executes the `clflush` instruction in a loop over the memory range.
3. On **AArch64**: The library executes the `dc civac` instruction in a loop over the memory range.
4. On **Other architectures**: The library calls the `_cache_line_flush` function in the C library, which in turn calls `__builtin_clear_cache()`.
5. The cache lines are flushed, ensuring subsequent accesses go to main memory (or at least are removed from the current cache levels).