async-alloc-counter measures max allocations in a future invocation

Geoffroy Couprie

Last update: Dec 3, 2021

Related tags

Utilities async-alloc-counter

Overview

async-alloc-counter measures max allocations in a future invocation

see examples/ for usage

This allocator can be used as follows:

use async_alloc_counter::*;
use futures::FutureExt;
use std::{alloc::System, time::Duration};

// set up the counting allocator
#[global_allocator]
static GLOBAL: AsyncAllocatorCounter<System> = AsyncAllocatorCounter { allocator: System };

#[tokio::main]
async fn main() {
  async move {
    let mut v: Vec<u8> = Vec::with_capacity(1024);
  }.count_allocations()
   .map(move |(max, ())| {
     println!("future allocated {} max bytes",  max);
   })
   .await
}

Allocation measurement can be stacked:

  = Vec::with_capacity(256); async move { let mut v: Vec
   = Vec::with_capacity(1024); }.count_allocations() .map(move |(max, ())| { println!("future allocated {} max bytes", max); }) .await }.count_allocations() .map(move |(max, ())| { println!("warpping future allocated {} max bytes", max); }) .await "> 
  async move {
  println!("wrapping future");
  tokio::time::sleep(std::timeDuration::from_secs(1)).await;
  let mut v: Vec<u8> = Vec::with_capacity(256);

  async move {
      let mut v: Vec<u8> = Vec::with_capacity(1024);
    }.count_allocations()
     .map(move |(max, ())| {
       println!("future allocated {} max bytes",  max);
     })
     .await
  }.count_allocations()
   .map(move |(max, ())| {
     println!("warpping future allocated {} max bytes",  max);
   })
   .await 
 

Design inspired by the excellent tracing crate

Rust Stream::buffer_unordered where each future can have a different weight.

buffer-unordered-weighted buffer_unordered_weighted is a variant of buffer_unordered, where each future can be assigned a different weight. This crate

15 Dec 28, 2022

Alternative future adapters that provide cancel safety.

cancel-safe-futures Alternative futures adapters that are more cancel-safe. What is this crate? The futures library contains many adapters that make w

12 Jul 2, 2023

Async executor for WebAssembly

There are a number of async task executors available in Rust's ecosystem. However, most (if not all?) of them rely on primitives that might not be available or optimal for WebAssembly deployment at the time.

65 Dec 31, 2022

The feature-rich, portable async channel library

The feature-rich, portable async channel library crates.io docs.rs Why use Postage? Includes a rich set of channels. | barrier | broadcast | dispa

221 Dec 26, 2022

Mix async code with CPU-heavy thread pools using Tokio + Rayon

tokio-rayon Mix async code with CPU-heavy thread pools using Tokio + Rayon Resources Documentation crates.io TL;DR Sometimes, you're doing async stuff

74 Jan 2, 2023

Another Async IO Framework based on io_uring

kbio, the Async IO Framework based on io_uring, is used in KuiBaDB to implement async io. Features Support multi-threading concurrent task submission.

59 Oct 31, 2022

Golang like WaitGroup implementation for sync/async Rust.

wg Golang like WaitGroup implementation for sync/async Rust.

8 Dec 6, 2022

single file, std only, async Rust executor

whorl - A single file, std only, async Rust executor whorl was created to teach you how async executors work in Rust. It is not the fastest executor n

459 Dec 29, 2022

BPF library for Async Rust, complementary for libbpf-rs.

libbpf-async A library for writing BPF programs in Async Rust, complementary for libbpf-rs, Rust wrapper for libbpf. Currently, this provides Async-fr