Tutorial for setting up SSH on a CHI@Edge container

An introduction to Chameleon's edge/IoT capabilities.

The simplest place to start with Chameleon artifacts

This tutorial artifact showcases the usage of a sense hat housing several environmental sensors of different kinds and an expansion board for adding more GPIO peripherals.

This artifact is aimed at showcasing the usage of a Pi Camera Module 3 on CHI@Edge

Automate system deployment and application lifecycle management with an MLOps pipeline on Chameleon

Practice using persistent storage (block and object storage) on Chameleon.

A FOUNT courselet that introduces how to use pandas for data analysis

This courselet provides information on using pandas to do data cleaning

A courselet on how to implement selection and brushing in data visualization

Practice evaluating a machine learning system by closing the feedback loop.

A detailed guide to using color in data visualizations

An introduction to constructing data visualizations using the pyobsplot library

An introduction to constructing data visualizations using the matplotlib library

Practice evaluating ML systems offline (Part 1 of 3)

This artifact contain an example on how to run AdaptSize on LibCacheSim.

This courselet on Software RAID provides a comprehensive guide to creating, managing, and dismantling a RAID 1 array on Ubuntu, emphasizing its redundancy benefits and performance/capacity drawbacks.

This courselet on Software RAID provides a comprehensive guide to creating, managing, and dismantling a RAID 0 array on Ubuntu, emphasizing its performance benefits and lack of redundancy.

This artifact is my implementation of ClockPro on libCacheSim

Practice evaluating ML systems online (Part 2 of 3)

This artifact initializes a VM at KVM@TACC with multiple storage volumes using the CHI and Cinder APIs.

Artifact of the paper "ExLi: An Inline-Test Generation Tool for Java" from FSE 2024.

Artifact of the paper "SixthSense: Debugging Convergence Problems in Probabilistic Programs via Program Representation Learning" from FASE 2022.

Artifact of the paper "Testing Probabilistic Programming Systems" from ESEC/FSE 2018.

Artifact of the paper "GlueTest: Testing Code Translation via Language Interoperability" from ICSME NIER 2024.

Artifact of the paper "FLEX: Fixing Flaky Tests in Machine Learning Projects by Updating Assertion Bounds" from ESEC/FSE 2021.

Serve ML models from edge devices on Chameleon.

Practice system-level optimizations for inference serving on Chameleon.

Practice model-level optimizations for inference serving on Chameleon.

Deploy MLFlow and Ray on Chameleon.

Connect Google Colab to a server on Chameleon

This project aims to explore and benchmark various machine learning models to detect disks at high risk of experiencing fail-slow anomalies.

This notebook reproduce bugs found by Acto.

Artifact for a SC24 paper

This is the Trovi package for the bug reproduction of FLINK-25728 of CMSC 33200

RpcMetrics should not be retained forever — Memory leak caused by RpcMetrics not being deregistered from DefaultMetricsSystem on session shutdown.

This Artifact Reproduce HDFS-14366

Examples for using fabnetv4 to connect Chameleon Sites and FABRIC

To aid artifact evaluation for Baleen (accepted to FAST 2024)

Setting up donkeycar autonomous

Reproducing Roller paper from OSDI'22

This is a draft... So please don't share it....

Examples of using FABRIC from the Chameleon JupyterHub

Reproducing the HDFS-14547 in BareMetal Environment

Benchmark different filesystems on top of Chameleon SSDs

Run multiple workloads on an existing filesystem (ext4)

Local RDMA InfiniBand Performance Test

Towards Reproducible Data Science Platform for Storage Systems

Trovi artifact for IndySCC Chameleon assignment.

Multi-platform experiments: Chameleon; Grid'5000 and FIT IoT LAB.

Deliverable for Team Revontuli for the first IndySCC 2022 assignment

Experiments testing the effect of quantization on inference time across frameworks, hardware and models.

Fine-tune a LLM across multiple GPUs on Chameleon.

This courselet teaches disk partitioning and file system management using Chameleon KVM virtual machines, covering tasks from creating and verifying partitions to securely deleting them.

This courselet guides users through benchmarking disk I/O performance, covering setup, performance measurement with tools like dd and FIO, and ensuring proper cleanup to maintain data integrity and sy

Learn cloud computing fundamentals on Chameleon.

This is a first, simple experiment on Chameleon, useful for familiarizing new experimenters with the platform.

Artifact of the paper "Silhouette: Leveraging Consistency Mechanisms to Detect Bugs in Persistent Memory-Based File Systems" from USENIX FAST '25.

This template can be used to set up a GPU/CPU node for one-click-reproducible experiments that involve docker

This template can be used to set up a node for one-click-reproducible experiments that involve the Guix package manager

This template can be used to set up node for one-click-reproducible experiments that involve the nix package manager

Fix RMNodeImpl.updateExistContainers leak

A courselet for data integration

A courselet teaching about data transformation

LogThrottlingHelper: the dependent recorder is not triggered correctly

This Artifact Reproduce IGNITE-16582

A demonstration of data collected using FLOTO software and devices

The easiest way to get up and running with Chameleon

This Artifact Reproduce IGNITE-16600

a pipeline to evaluate drift detection algorithms on system traces

A reproducible artifact for the LAST project

This Artifact Reproduce IGNITE-17407

This Artifact Reproduce IGNITE-20614

Reproducing the OSDI 2024 Anvil: Verifying Liveness of Cluster Management Controllers

Reproduce + build on a classic ML result from 1989.

This notebook reproduces figures from the Privbox paper from ATC '22.

Demonstrate speed and efficacy of the Rust-based, kernel module schedulers provided,

Reproduction of YARN-9565, before and after the patch

Show the image of performance degradation of a bug in HDFS

Reproducing and fixing SPARK-30511, marking intentionally killed speculative tasks as pending leading to holding idle executors

Performance degradation when having no ObserverNode in HAService mode.

Reproduction of YARN-9565, before and after the patch

The ShuffleStatus serialization is implemented in synchronized block, which scale badly when number of executors increases.

This artifact reproduces the Orc connection leak bug published in FLINK-29412.

Reproducing "Interrupting RPC Client calls can lead to thread exhaustion"

Reproducing the performance degradation of the Hadoop's safe mode condition checking.

Reproducing SPARK-47146 Possible thread leak when doing sort merge join

using python-chi and ansible to set up MPI (and other) clusters on Chameleon

Reproduces the S2TT results from the Seamless and Whisper models

Server node copies a lot of WAL files in WAL archive after restart

This Artifact Reproduce IGNITE-14341

This Artifact Reproduce hadoop

The pos Experiment Controller

Deploy 3 VMs on a network and configure them as a Kubernetes cluster

A example of launching a container to aid in development of FLOTO services

Deploy Chameleon, on Chameleon! For CHI-in-a-Box explorers.

OutputSink.WriterThread exception gets stuck and repeated indefinietly

This Artifact Reproduce HDFS-13821

This Artifact Reproduce HDFS-12567

This Artifact Reproduce HDFS-15211

Introduces Python and important packages to coding novices

Emulating network impairments (bandwidth limits, delay, jitter, packet loss)

Network topologies + configurations for teaching computer networks on Chameleon.

This Artifact Reproduce HDFS-14973

Data Acquisition using Sage Data Client API

Data Acquisition using CHI@Edge and Raspberry Pi 4

Data acquisition by cron scheduling and web scraping.

HADOOP-18146 reproduction

Reproduce Bugs: Yarn Logs Command retrying on Standby RM for 30 times

This is the artifact for the FAST '24 paper "ELECT: Enabling Erasure Coding Tiering for LSM-tree-based Storage".

This Artifact Reproduce IGNITE-17043

The artifact for reproducing the FAST '24 paper "RFUSE: Modernizing Userspace Filesystem Framework through Scalable Kernel-Userspace Communication".

Metis is a differential-testing-based model-checking framework designed for versatile, thorough, yet configurable file system testing in the form of input and state exploration.

This Artifact Reproduce IGNITE-14076

This Artifact Reproduce IGNITE-13856

This Artifact Reproduce IGNITE-12087

This Artifact Reproduce HADOOP-16850

Experimental to reproduce

This Artifact Reproduce CASSANDRA-12245

This experiment tries to reproduce the results of the smaller experiment of Andrej Karpathy's NanoGPT.

5-step courselet on Machine Learning Processing

SC23 MLEC Artifact

Practice using tcpdump and Wireshark, two software applications for packet capture and packet analysis

Using edge devices for CPU-based inference

Using cloud servers for GPU-based inference

The IC2E paper

This is interactive material for teaching machine learning using reproducibility.

This is interactive material for teaching machine learning using reproducibility.

This artifact shows how to create a reproducible experiment on Chameleon using an implementation of the AlexNet model on the Stanford Dogs dataset.

See title.

Creating a cluster in Chameleon Cloud through Jupyter notebook and the Python CHI library

Deploy a secure compute cluster behind a single public IP address

Create a Ryu controller and an isolated OpenFlow network with nodes.

Provision a small GPU cluster of one or many nodes

Install JupyterHub on your instance, and run experiments in the cloud

Get a barebones Jupyter server running on powerful hardware

A rundown on the different ways to manage data in Chameleon

Orchestrating your experiments with Heat templates

Intended to be an introduction to Chameleon's KVM cloud.

Example data analysis Notebook looking at usage patterns on Chameleon

outdated artifact

Reproducing SpecREDS paper from ATC'22

ATC/OSDI 2023 BOF Filesystems Benchmark (FileBench)

FIO benchmark example run

Reproduce the LinnOS experiment with in LAKE

Simple FIO benchmark example run

ATC/OSDI 2023 BoF FlashNet

Local RDMA InfiniBand performance test such as bandwidth and latency

FileBench workloads simulation

test doi limitations

This artifact reproduces SPARK-29938

This artifact reproduces SPARK-25947

This artifact reproduces IGNITE-11524

This artifact reproduces CASSANDRA-15902

This artifact reproduces CASSANDRA-15400

This artifact reproduces IGNITE-14003

Concierge experiment setup, run, analysis

This artifact reproduces CASSANDRA-16201

An introduction to using Jupyter Bash notebooks for Systems Education.

Reproducing the result of the paper "Exploring the ..."

Examples of how to use the openstacksdk libraries with ChameleonCloud

Materials for reproducing some qualitative claims in Tacotron2 paper

I created a notebook for loading the excel file

I created a notebook for loading the excel file

Exception in WriterThread never removed.

This artifact reproduce IGNITE-11524

Reproducing Kafka bug KAFKA-10846 for Ethan's CS332 final project

Thread leak related scalability bug reproduction

reproducing FLINK-10774

Reproduction of the bug HADOOP-16435

Reproducing SPARK-34087 scalability bugs which will cause memory leak

Towards Reproducible Data Science Platform for Storage Systems

FIO Benchmark for SSD, RAID group, and RAM disk

Simple FIO Benchmark on RAM disk and SSD.

Examples of using FABRIC

Assignment 1

Everything that is asked for in the directions.

Chameleon Task 1.2 JSON and Task 1.3 jupyter scripts

IndySCC Chameleon Assignment submitted by Kambing Cluster

Run iperf3 on sharednet1 and isolated network.

Basics of creating instances and networks

Basics of creating instances and networks

Run and Benchmark Ceph Object Storage

A tutorial notebook for Chameleon shared filesystem service

Quickstart MinIO on single-node k8

Deploying CORTX-k8

An experiment that runs from Edge to Cloud.

A quick intro on how to reserve and launch instances

Deploying CORTX Motr

LinnOS Artifact

A set of tutorials and examples on testbed networking capabilities

Benchmarking the GC algorithms for concurrent and web tasks

A demo of serverless idempotency violation issue

Chameleon SSDs Benchmark using FIO

The demonstration of FlyMC to catch the DC bugs.

Training MNIST benchmark with PyTorch

tinyTailFlash DTRS experiment

A benchmark for evaluating machine learning optimizations (Tensorflow)

Set of tutorial notebooks for reserving baremetal instances

Connecting Chameleon Experiments to AWS using DirectConnect Circuits

Reproduction using Chameleon and OpenStack tools

Runs HPCG and HPL

Creates Twp Baremetal Nodes that are located on the same rack

A short ML experiment showcasing how to use TensorFlow and Chameleon

Automating Bare Metal Creation

Reserve and Provision a node with a given hardware device

QR Code for the poster

A data-driven cloud simulator.

A Machine Learning Experiment for Chameleon and OpenStack