{"id":49367183,"url":"https://github.com/logannye/emsqrt","last_synced_at":"2026-04-27T20:02:32.253Z","repository":{"id":322389611,"uuid":"1089274141","full_name":"logannye/emsqrt","owner":"logannye","description":"Process any data size with a fixed, small memory footprint. EM-√ is an external-memory ETL/log processing engine with hard peak-RAM guarantees. Unlike traditional systems that \"try\" to stay within memory limits, EM-√ enforces a strict memory cap, enabling you to process arbitrarily large datasets using small memory footprints.","archived":false,"fork":false,"pushed_at":"2025-11-18T04:58:55.000Z","size":290,"stargazers_count":3,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-11-18T06:23:46.509Z","etag":null,"topics":["big-data","big-data-analytics","cloud","cloud-computing","edge-ai","edge-computing","efficiency","efficient-algorithm","memory-allocation","rust","streaming","streaming-algorithms","streaming-data"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/logannye.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-11-04T05:50:15.000Z","updated_at":"2025-11-18T04:58:59.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/logannye/emsqrt","commit_stats":null,"previous_names":["logannye/emsqrt"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/logannye/emsqrt","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/logannye%2Femsqrt","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/logannye%2Femsqrt/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/logannye%2Femsqrt/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/logannye%2Femsqrt/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/logannye","download_url":"https://codeload.github.com/logannye/emsqrt/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/logannye%2Femsqrt/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32352406,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-27T17:12:42.749Z","status":"ssl_error","status_checked_at":"2026-04-27T17:12:41.658Z","response_time":128,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["big-data","big-data-analytics","cloud","cloud-computing","edge-ai","edge-computing","efficiency","efficient-algorithm","memory-allocation","rust","streaming","streaming-algorithms","streaming-data"],"created_at":"2026-04-27T20:02:29.276Z","updated_at":"2026-04-27T20:02:32.238Z","avatar_url":"https://github.com/logannye.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# EM-√ (EM-Sqrt): External-Memory ETL Engine\n\n## **Process any dataset size with a fixed, small memory footprint.**\n\n[![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE)\n[![Rust](https://img.shields.io/badge/Rust-1.70+-orange.svg)](https://www.rust-lang.org/)\n\n\nEM-√ is an external-memory ETL/log processing engine with **hard peak-RAM guarantees**. Unlike traditional systems that \"try\" to stay within memory limits, EM-√ **enforces** a strict memory cap, enabling you to process arbitrarily large datasets using small memory footprints.\n\n## Key Features\n\n- **Hard Memory Guarantees**: Never exceeds the configured memory cap (default 512MB). All allocations are tracked via RAII guards.\n- **External-Memory Operators**: Sort, join, and aggregate operations automatically spill to disk when memory limits are hit.\n- **Tree Evaluation (TE) Scheduling**: Principled execution schedule that decomposes plans into blocks with bounded fan-in to control peak memory.\n- **Cloud-Ready**: Spill segments support local filesystem with checksums and compression. S3 and GCS adapters are planned.\n- **Pluggable Spill Storage**: Point spills at local paths or cloud object stores (S3, GCS, Azure) with retry/backoff controls.\n- **Parquet Support**: Native columnar Parquet I/O with Arrow integration (optional `--features parquet`).\n- **Grace Hash Join**: Automatic partition-based hash join for datasets exceeding memory limits.\n- **Deterministic Execution**: Stable plan hashing for reproducibility and auditability.\n- **Memory-Constrained Environments**: Designed for edge computing, serverless, embedded systems, and containerized deployments.\n\n## Quick Start\n\n### Installation\n\n```bash\n# Clone the repository\ngit clone https://github.com/logannye/emsqrt.git\ncd emsqrt\n\n# Build the project\ncargo build --release\n\n# Run tests\ncargo test\n```\n\n### Basic Usage\n\n#### Programmatic API\n\n```rust\nuse emsqrt_core::schema::{Field, DataType, Schema};\nuse emsqrt_core::dag::LogicalPlan as L;\nuse emsqrt_core::config::EngineConfig;\nuse emsqrt_planner::{rules, lower_to_physical, estimate_work};\nuse emsqrt_te::plan_te;\nuse emsqrt_exec::Engine;\n\n// Define your schema\nlet schema = Schema {\n    fields: vec![\n        Field::new(\"id\", DataType::Int64, false),\n        Field::new(\"name\", DataType::Utf8, false),\n        Field::new(\"age\", DataType::Int64, false),\n    ],\n};\n\n// Build a logical plan: scan → filter → project → sink\nlet scan = L::Scan {\n    source: \"file:///path/to/input.csv\".to_string(),\n    schema: schema.clone(),\n};\n\nlet filter = L::Filter {\n    input: Box::new(scan),\n    expr: \"age \u003e 25\".to_string(),\n};\n\nlet project = L::Project {\n    input: Box::new(filter),\n    columns: vec![\"name\".to_string(), \"age\".to_string()],\n};\n\nlet sink = L::Sink {\n    input: Box::new(project),\n    destination: \"file:///path/to/output.csv\".to_string(),\n    format: \"csv\".to_string(),\n};\n\n// Optimize and execute\nlet optimized = rules::optimize(sink);\nlet phys_prog = lower_to_physical(\u0026optimized);\nlet work = estimate_work(\u0026optimized, None);\nlet te = plan_te(\u0026phys_prog.plan, \u0026work, 512 * 1024 * 1024)?; // 512MB memory cap\n\n// Configure and run\nlet mut config = EngineConfig::default();\nconfig.mem_cap_bytes = 512 * 1024 * 1024; // 512MB\nconfig.spill_dir = \"/tmp/emsqrt-spill\".to_string();\n\nlet mut engine = Engine::new(config).expect(\"engine initialization\");\nlet manifest = engine.run(\u0026phys_prog, \u0026te)?;\n\nprintln!(\"Execution completed in {}ms\", manifest.finished_ms - manifest.started_ms);\n```\n\n#### YAML DSL\n\nThe YAML DSL supports linear pipelines with the following operators:\n\n```yaml\nsteps:\n  - op: scan\n    source: \"data/logs.csv\"\n    schema:\n      - { name: \"ts\", type: \"Utf8\", nullable: false }\n      - { name: \"uid\", type: \"Utf8\", nullable: false }\n      - { name: \"amount\", type: \"Float64\", nullable: true }\n  \n  - op: filter\n    expr: \"amount \u003e 1000\"\n  \n  - op: project\n    columns: [\"ts\", \"uid\", \"amount\"]\n  \n  - op: sink\n    destination: \"results/filtered.csv\"\n    format: \"csv\"  # or \"parquet\" (requires --features parquet)\n```\n\n**Note**: Currently supports `scan`, `filter`, `project`, `map`, and `sink`. Aggregate and join operators are not yet supported in YAML (use the programmatic API for these operations).\n\nAdd an optional `config` block to describe spill targets without touching CLI flags:\n\n```yaml\nconfig:\n  spill_uri: \"s3://my-bucket/spill\"\n  spill_aws_region: \"us-east-1\"\n  spill_gcs_service_account: \"/path/to/service-account.json\"\nsteps:\n  - op: scan\n    source: \"data/logs.csv\"\n    schema: []\n  - op: sink\n    destination: \"stdout\"\n    format: \"csv\"\n```\n\nValues from `config` merge with environment variables and command-line overrides.\n\n**Parquet Support**: Scan and Sink operators support Parquet format when built with `--features parquet`. Files are automatically detected by extension (`.parquet`, `.parq`) or can be explicitly specified with `format: \"parquet\"`.\n\n#### CLI Usage\n\nThe EM-√ CLI provides a convenient way to run pipelines from YAML files:\n\n```bash\n# Validate a pipeline YAML file\nemsqrt validate --pipeline examples/simple_pipeline.yaml\n\n# Show execution plan (EXPLAIN)\nemsqrt explain --pipeline examples/simple_pipeline.yaml --memory-cap 536870912\n\n# Execute a pipeline\nemsqrt run --pipeline examples/simple_pipeline.yaml\n\n# Override configuration via command-line flags\nemsqrt run \\\n  --pipeline examples/simple_pipeline.yaml \\\n  --memory-cap 1073741824 \\\n  --spill-uri s3://my-bucket/spill \\\n  --spill-aws-region us-east-1 \\\n  --spill-aws-access-key-id AKIA... \\\n  --spill-aws-secret-access-key SECRET... \\\n  --spill-gcs-service-account /path/to/sa.json \\\n  --spill-azure-access-key azureKey \\\n  --spill-retry-max 5 \\\n  --spill-dir /tmp/emsqrt-spill \\\n  --max-parallel 4\n```\n\nSee `examples/README.md` for more details on YAML pipeline syntax.\n\n### Cloud Spill Authentication\n\nWhen using S3/GCS/Azure spill URIs, provide credentials via CLI flags, environment variables, or the platform's SDK defaults:\n\n- **S3**: export `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY` or use `aws configure`; optionally include `--spill-aws-region`.\n- **GCS**: set `GOOGLE_SERVICE_ACCOUNT`/`GOOGLE_SERVICE_ACCOUNT_PATH` or run `gcloud auth application-default login`.\n- **Azure**: use `az login` and `AZURE_STORAGE_CONNECTION_STRING` or pass `--spill-azure-access-key`.\n\nThe `config` block in `examples/cloud_spill/pipeline.yaml` illustrates a spill URI plus retry tuning so you can avoid repeating CLI flags per run.\n\n## Examples of Practical Use Cases\n\n### 1. Serverless Data Pipelines\n\nProcess large datasets in AWS Lambda, Google Cloud Functions, or Azure Functions with strict memory limits:\n\n```rust\n// Process 100GB dataset in a 512MB Lambda\n// Note: S3 spill support is planned; currently use local filesystem\nlet config = EngineConfig {\n    mem_cap_bytes: 512 * 1024 * 1024, // 512MB\n    spill_dir: \"/tmp/lambda-spill\".to_string(),\n    ..Default::default()\n};\n```\n\n**Value**: 10-100x cost reduction vs. large EC2 instances or EMR clusters.\n\n### 2. Edge Data Processing\n\nAggregate sensor data on IoT gateways or embedded devices with limited RAM:\n\n```rust\n// Process 1M sensor readings on a Raspberry Pi with 256MB RAM\nlet config = EngineConfig {\n    mem_cap_bytes: 128 * 1024 * 1024, // Use only 128MB\n    spill_dir: \"/tmp/sensor-spill\".to_string(),\n    ..Default::default()\n};\n```\n\n**Value**: Enable edge analytics without hardware upgrades.\n\n### 3. Multi-Tenant Data Platforms\n\nRun customer queries with isolated memory budgets:\n\n```rust\n// Each customer gets a memory budget\n// Note: S3 spill support is planned; currently use local filesystem\nlet config = EngineConfig {\n    mem_cap_bytes: customer_memory_budget,\n    spill_dir: format!(\"/tmp/platform-spill/customer-{}\", customer_id),\n    ..Default::default()\n};\n```\n\n**Value**: Predictable performance, resource isolation, accurate cost attribution.\n\n### 4. Cost-Optimized Analytics\n\nUse smaller, cheaper instances by trading I/O for memory:\n\n```rust\n// Process 500GB dataset on a 4GB RAM instance instead of 64GB\nlet config = EngineConfig {\n    mem_cap_bytes: 4 * 1024 * 1024 * 1024, // 4GB\n    spill_dir: \"/fast-nvme/spill\".to_string(),\n    ..Default::default()\n};\n```\n\n**Value**: 10x cost reduction for memory-bound workloads.\n\n## Architecture\n\nEM-√ is built as a modular Rust workspace with the following crates:\n\n```\nemsqrt-core/      - Core types, schemas, DAGs, memory budget traits\nemsqrt-te/        - Tree Evaluation planner (bounded fan-in decomposition)\nemsqrt-mem/       - Memory budget implementation, spill manager, buffer pool\nemsqrt-io/        - I/O adapters (CSV, JSONL, Parquet, storage backends)\nemsqrt-operators/ - Query operators (filter, project, sort, join, aggregate)\nemsqrt-planner/   - Logical/physical planning, optimization, YAML DSL\nemsqrt-exec/      - Execution runtime, scheduler, engine\nemsqrt-cli/       - Command-line interface for running pipelines\n```\n\n### Execution Flow\n\n1. **Planning**: YAML/Logical plan → Optimized logical plan → Physical plan with operator bindings\n2. **TE Scheduling**: Physical plan → Tree Evaluation blocks with bounded fan-in\n3. **Execution**: Blocks executed in dependency order, respecting memory budget\n4. **Spilling**: Operators automatically spill to disk when memory limits are hit\n5. **Manifest**: Deterministic execution manifest with plan hashes for reproducibility\n\n### Memory Management\n\n- **MemoryBudget**: RAII guards track all allocations\n- **SpillManager**: Checksummed, compressed segments for external-memory operations\n- **TE Frontier**: Bounded live blocks guarantee peak memory ≤ cap\n\n## Configuration\n\n### EngineConfig\n\n```rust\npub struct EngineConfig {\n    /// Hard memory cap (bytes). The engine must NEVER exceed this.\n    pub mem_cap_bytes: usize,\n    \n    /// Optional block-size hint (TE planner may override)\n    pub block_size_hint: Option\u003cusize\u003e,\n    \n    /// Max on-disk spill concurrency\n    pub max_spill_concurrency: usize,\n    \n    /// Optional seed for deterministic shuffles\n    pub seed: Option\u003cu64\u003e,\n    \n    /// Execution parallelism\n    pub max_parallel_tasks: usize,\n    \n    /// Directory for spill files\n    pub spill_dir: String,\n}\n```\n\n### Environment Variables\n\n```bash\nexport EMSQRT_MEM_CAP_BYTES=536870912  # 512MB\nexport EMSQRT_SPILL_DIR=/tmp/emsqrt-spill\nexport EMSQRT_MAX_PARALLEL_TASKS=4\nexport EMSQRT_SPILL_URI=s3://my-bucket/emsqrt\nexport EMSQRT_SPILL_AWS_REGION=us-east-1\nexport EMSQRT_SPILL_AWS_ACCESS_KEY_ID=AKIA...\nexport EMSQRT_SPILL_AWS_SECRET_ACCESS_KEY=SECRET...\nexport EMSQRT_SPILL_AWS_SESSION_TOKEN=optionalSession\nexport EMSQRT_SPILL_GCS_SA_PATH=/path/to/service-account.json\nexport EMSQRT_SPILL_AZURE_ACCESS_KEY=azureKey\nexport EMSQRT_SPILL_RETRY_MAX_RETRIES=5\nexport EMSQRT_SPILL_RETRY_INITIAL_MS=250\nexport EMSQRT_SPILL_RETRY_MAX_MS=5000\n```\n\n### Default Configuration\n\n```rust\nEngineConfig::default()\n// mem_cap_bytes: 512 MiB\n// max_spill_concurrency: 4\n// max_parallel_tasks: 4\n// spill_dir: \"/tmp/emsqrt-spill\"\n```\n\n#### StorageConfig\n\n```rust\npub struct StorageConfig {\n    pub uri: Option\u003cString\u003e,        // e.g. s3://bucket/prefix\n    pub root: String,               // normalized spill root\n    pub aws_region: Option\u003cString\u003e,\n    pub aws_access_key_id: Option\u003cString\u003e,\n    pub aws_secret_access_key: Option\u003cString\u003e,\n    pub aws_session_token: Option\u003cString\u003e,\n    pub gcs_service_account_path: Option\u003cString\u003e,\n    pub azure_access_key: Option\u003cString\u003e,\n    pub retry_max_retries: usize,\n    pub retry_initial_backoff_ms: u64,\n    pub retry_max_backoff_ms: u64,\n}\n```\n\n`EngineConfig::storage_config()` produces this snapshot and `emsqrt-io` uses it to choose between filesystem and cloud adapters.\n\n## Building \u0026 Testing\n\n### Build\n\n```bash\n# Debug build\ncargo build\n\n# Release build (optimized)\ncargo build --release\n\n# Build specific crate\ncargo build -p emsqrt-exec\n```\n\n### Run Tests\n\n```bash\n# All tests (unit tests in crates)\ncargo test --all --lib\n\n# Specific test suite (in workspace root tests/ directory)\ncargo test --test integration_tests\ncargo test --test expression_tests\ncargo test --test cost_estimation_tests\n\n# Run comprehensive test suite (10 phases)\n./scripts/run_all_tests.sh\n```\n\n### Test Coverage\n\nThe comprehensive test suite (`scripts/run_all_tests.sh`) includes 10 phases:\n\n1. **Unit Tests**: SpillManager, RowBatch helpers, Memory budget\n2. **Integration Tests**: Full pipeline tests (scan, filter, project, sort, aggregate, sink, join)\n3. **E2E Tests**: End-to-end smoke tests\n4. **Crate-Level Tests**: All library unit tests across crates\n5. **Expression Engine Tests**: Expression parsing and evaluation\n6. **Column Statistics Tests**: Statistics collection and cost estimation\n7. **Error Handling Tests**: Error context and recovery\n8. **Operator Tests**: Merge join, filter with expressions\n9. **Feature-Specific Tests**: Parquet, Arrow (when features enabled)\n10. **CLI Tests**: YAML parsing and validation\n\n## Supported Operations\n\n### Currently Implemented\n\n- ✅ **Scan**: Read CSV and Parquet files with schema inference\n- ✅ **Filter**: Predicate filtering (e.g., `age \u003e 25`, `name == \"Alice\"`)\n- ✅ **Project**: Column selection and renaming\n- ✅ **Map**: Column renaming (e.g., `old_name AS new_name`)\n- ✅ **Sort**: External sort with k-way merge\n- ✅ **Aggregate**: Group-by with COUNT, SUM, AVG, MIN, MAX\n- ✅ **Join**: Hash join (with Grace hash join for large datasets), merge join (sorted merge join for pre-sorted inputs)\n- ✅ **Sink**: Write CSV and Parquet files\n- ✅ **Expression Engine**: Full SQL-like expressions with operator precedence, cross-type arithmetic, and logical operations\n- ✅ **Statistics**: Column statistics (min/max/distinct_count/null_count) for cost estimation and selectivity modeling\n- ✅ **Parquet I/O**: Native columnar read/write with Arrow integration (requires `--features parquet`)\n- ✅ **Arrow Integration**: Columnar processing with RecordBatch ↔ RowBatch conversion utilities\n- ✅ **Grace Hash Join**: Partition-based hash join for very large datasets with automatic spilling\n\n### Planned Features\n\n- 🔄 **Cloud Storage**: S3, GCS adapters for spill segments (currently filesystem only)\n\n## How It Works\n\n### Tree Evaluation (TE)\n\nTree Evaluation is a principled execution scheduling approach that:\n\n1. **Decomposes plans into blocks** with bounded fan-in (e.g., each join block depends on at most K input blocks)\n2. **Controls the live frontier** (the set of materialized blocks at any time)\n3. **Guarantees peak memory** ≤ `K * block_size + overhead`\n\n### External-Memory Operators\n\nWhen memory limits are hit, operators automatically:\n\n1. **Spill to disk**: Write intermediate results to checksummed, compressed segments\n2. **Partition**: Divide work into smaller chunks that fit in memory\n3. **Merge**: Combine results from multiple partitions/runs\n\nExample: External sort generates sorted runs, then performs k-way merge.\n\n### Memory Budget Enforcement\n\nEvery allocation requires a `BudgetGuard`:\n\n```rust\nlet guard = budget.try_acquire(bytes, \"my-buffer\")?;\n// Allocate memory...\n// Guard automatically releases bytes on drop (RAII)\n```\n\nIf `try_acquire` returns `None`, the operator must spill or partition.\n\n## Performance\n\n### Benchmarks (Planned)\n\n- Sort 10GB with 512MB memory\n- Join 1GB × 1GB with 50MB memory\n- Aggregate 1M groups with 20MB memory\n- TPC-H queries (Q1, Q3, Q6)\n\nSee `docs/benchmarks.md` for the current Criterion harness and the `scripts/benchmarks/run_benchmarks.sh` helper.\n\n### Expected Characteristics\n\n- **Throughput**: 10-100x slower than in-memory systems (by design)\n- **Memory**: **Guaranteed** to never exceed cap (unlike other systems)\n- **Scalability**: Can process datasets 100-1000x larger than available RAM\n\n## Development\n\n### Project Structure\n\n```\nemsqrt/\n├── Cargo.toml              # Workspace configuration\n├── crates/\n│   ├── emsqrt-core/       # Core types and traits\n│   ├── emsqrt-te/          # Tree Evaluation planner\n│   ├── emsqrt-mem/         # Memory budget and spill manager\n│   ├── emsqrt-io/          # I/O adapters\n│   ├── emsqrt-operators/   # Query operators\n│   ├── emsqrt-planner/     # Planning and optimization\n│   ├── emsqrt-exec/        # Execution runtime\n│   └── emsqrt-cli/         # Command-line interface\n├── tests/                  # Integration and unit tests (workspace root)\n├── scripts/                # Utility scripts (run_all_tests.sh)\n├── examples/               # YAML pipeline examples\n└── README.md               # This file\n```\n\n### Adding a New Operator\n\n1. Implement the `Operator` trait in `emsqrt-operators/src/`\n2. Register in `emsqrt-operators/src/registry.rs`\n3. Add to planner lowering in `emsqrt-planner/src/lower.rs`\n4. Add tests in `tests/`\n\n### Code Style\n\n- Follow Rust standard formatting: `cargo fmt`\n- All code must compile with `#![forbid(unsafe_code)]`\n- Use `thiserror` for error types\n- Use `serde` for serialization\n\n## Contributing\n\nContributions are welcome! Areas of particular interest:\n\n- Cloud storage adapters (S3, GCS, Azure) - placeholders exist, need implementation\n- Additional operators (window functions, lateral joins)\n- YAML DSL support for aggregate and join operators\n- Performance optimizations (SIMD in Arrow operations, parallel processing)\n- Documentation improvements\n\n## Acknowledgments\n\nThis project implements Tree Evaluation (TE) scheduling for external-memory query processing, enabling predictable memory usage in constrained environments.\n\n---\n\n**Take-home**: EM-√ trades throughput for guaranteed memory bounds. Use it when memory constraints are more important than raw speed.\n\nRepo is a dynamic work, please be aware that it will evolve and further develop over time.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Flogannye%2Femsqrt","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Flogannye%2Femsqrt","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Flogannye%2Femsqrt/lists"}