lab3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cc9c5e41-4487-4e98-bb08-45f3f0874a16",
   "metadata": {},
   "source": [
    "# **LAB 3: Comparative Inference Benchmarking on ARM Server and Edge Devices**\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Welcome to Lab 3 in our series on **Optimizing Generative AI Workloads with ARM Processors**! In this lab, we shift our focus to evaluating the performance constraints of generative AI inference between ARM-based server and edge devices. Specifically, we'll use the **OpenELM-3B** model alongside the popular **llama.cpp** framework to benchmark and compare inference characteristics on two different ARM environments: a high-performance Graviton server based on the Neoverse processor and a comparatively resource-constrained Raspberry Pi5.\n",
    "\n",
    "Throughout this lab, you will:\n",
    "\n",
    "- **Benchmark thoughput Metrics**: Measure and compare the overall inference thoughput of both the prefill and generation stages of large language model transformers.\n",
    "- **Evaluate Memory Constraints**: Analyze how the OpenELM-3B model's memory constraints varies between an ARM server and an ARM-based edge device.\n",
    "- **Compare Edge and Server Constraints**: Understand the practical limitations and trade-offs when deploying large language models on different ARM CPUs, from powerful server-class processors to limited edge devices.\n",
    "- **Utilize llama.cpp Framework**: Leverage the llama.cpp framework for efficient model inference and performance measurement, allowing for cross-device comparisons.\n",
    "\n",
    "This lab will guide you through setting up the necessary environments, running inference benchmarks on both the Raspberry Pi and Graviton server, and interpreting the results. By the end of the lab, you'll gain insights into:\n",
    "\n",
    "- How hardware differences affect model performance\n",
    "- Strategies for optimizing inference on both server and edge ARM devices\n",
    "- Best practices for deploying large language models across diverse ARM architectures\n",
    "\n",
    "\n",
    "### **Lab Objectives**\n",
    "\n",
    "1. **Set Up Diverse ARM Environments**  \n",
    "   Prepare and configure both a Raspberry Pi (edge device) and an ARM Graviton server for inference benchmarking with the OpenELM-3B model and llama.cpp framework.\n",
    "\n",
    "2. **Benchmark Latency Metrics**  \n",
    "   Measure key performance indicators, including total inference latency, time-to-first-token (TTFT), and per-token decoding latency, on both devices.\n",
    "\n",
    "3. **Analyze Memory Consumption**  \n",
    "   Monitor and compare memory utilization during model inference to assess resource constraints on server and edge devices.\n",
    "\n",
    "4. **Compare Performance Constraints**  \n",
    "   Understand the practical implications of deploying large language models on resource-constrained edge devices versus powerful server environments. Identify bottlenecks and optimization opportunities for each scenario.\n",
    "\n",
    "5. **Document Findings and Insights**  \n",
    "   Compile your observations, compare the differences in performance, and suggest strategies to mitigate limitations on edge devices while leveraging server capabilities.\n",
    "\n",
    "### **What You Will Learn**\n",
    "\n",
    "- **ARM Environment Configuration**:  \n",
    "  Learn how to set up and configure both ARM-based server and edge devices for AI inference benchmarking.\n",
    "\n",
    "- **Performance Metric Analysis**:  \n",
    "  Understand techniques to measure and interpret key metrics such as throughput, time-to-first-token (TTFT), per-token decoding latency, and overall inference latency.\n",
    "\n",
    "- **Memory Utilization Insights**:  \n",
    "  Acquire methods to monitor and compare memory consumption during large language model inference across different hardware platforms.\n",
    "\n",
    "- **Hardware Trade-Offs and Optimization**:  \n",
    "  Explore the performance constraints and trade-offs between resource-constrained edge devices and high-performance server-class ARM processors, and learn strategies to mitigate these limitations.\n",
    "\n",
    "\n",
    "### **Prerequisites**\n",
    "\n",
    "- **Basic Understanding of Linux**: Familiarity with Linux command-line operations and system configuration.\n",
    "- **Experience with C/C++ and Python Programming**: Ability to modify, compile, and execute code with the help of instructions.\n",
    "- **Fundamentals of AI Inference**: Knowledge of how transformer inference works in large language models.\n",
    "- **Completion of Labs 1 and 2 (Recommended)**: Prior experience with ARM intrinsics, quantization, and performance benchmarking for generative AI workloads.\n",
    "- **Completion of Chapters 1, 2, 3 and 4**: Understanding of the concepts of KleidiAI microkernels, quantization, and performance benchmarking will be useful.\n",
    "\n",
    "\n",
    "**By the end of this lab**, you will have a comprehensive understanding of how ARM server and edge CPUs handle inference for large language models like OpenELM-3B. You will be equipped with the skills to benchmark and analyze prompt processing throughput, decoding performance, and memory consumption, enabling you to make informed decisions when deploying AI models across diverse ARM architectures.\n",
    "\n",
    "---\n",
    "\n",
    "# 1. Setting Up the Raspberry Pi for Inference Benchmarking\n",
    "\n",
    "Before proceeding, ensure you have completed the [Lab 1 setup script](#) on your Raspberry Pi. If not, start by running the setup script:\n",
    "\n",
    "```bash\n",
    "./setup_pi5.sh\n",
    "```\n",
    "\n",
    "Once the script completes, activate the newly created virtual environment:\n",
    "\n",
    "```bash\n",
    "source pi5_env/bin/activate\n",
    "```\n",
    "\n",
    "This ensures that all required packages for the lab are preinstalled.\n",
    "\n",
    "### Building the llama.cpp Inference Framework\n",
    "\n",
    "If you haven't already, download and build the [llama.cpp](https://github.com/ggerganov/llama.cpp) inference framework with ARM CPU optimizations:\n",
    "\n",
    "1. **Clone this repository:**\n",
    "\n",
    "   ```bash\n",
    "   git clone https://github.com/ggerganov/llama.cpp\n",
    "   ```\n",
    "\n",
    "2. **Configure the build:**\n",
    "\n",
    "   ```bash\n",
    "   cmake -B llama.cpp/build -S llama.cpp -DCMAKE_CXX_FLAGS=\"-mcpu=native\" -DCMAKE_C_FLAGS=\"-mcpu=native\"\n",
    "   ```\n",
    "\n",
    "3. **Compile the framework:**\n",
    "\n",
    "   ```bash\n",
    "   cmake --build llama.cpp/build --config Release -j$(nproc) -v\n",
    "   ```\n",
    "\n",
    "These commands build the framework optimized for your ARM CPU.\n",
    "\n",
    "### Downloading the OpenELM-3B Model Weights\n",
    "\n",
    "Next, download the large language model weights from Hugging Face. Follow these steps:\n",
    "\n",
    "1. Create a Python file named `download_openelm.py` in the root directory with the following content:\n",
    "\n",
    "   ```python\n",
    "   from huggingface_hub import snapshot_download\n",
    "\n",
    "   # Specify the target directory for downloading the model\n",
    "   target_directory = \"models/hf_models/OpenELM-3B-Instruct\"\n",
    "\n",
    "   # Download a snapshot of the model repository\n",
    "   snapshot_download(\n",
    "       repo_id=\"apple/OpenELM-3B-Instruct\",\n",
    "       local_dir=target_directory,\n",
    "       revision=\"main\",  # Optional: specify a branch, tag, or commit hash\n",
    "       local_dir_use_symlinks=False  # Set to True if you want symlinks instead of file copies\n",
    "   )\n",
    "   ```\n",
    "\n",
    "2. Run the script to start downloading the model weights:\n",
    "\n",
    "   ```bash\n",
    "   python download_openelm.py\n",
    "   ```\n",
    "\n",
    "   > **Note:** The download may take around 20 minutes, depending on your internet speed, as the model is large (~3 billion parameters).\n",
    "\n",
    "### Converting and Quantizing the Model\n",
    "\n",
    "Once the model is downloaded, convert it to the GGUF format and quantize it for inference:\n",
    "\n",
    "1. **Convert the model to GGUF format:**\n",
    "\n",
    "   ```bash\n",
    "   mkdir -p models/gguf_models\n",
    "\n",
    "   python llama.cpp/convert_hf_to_gguf.py models/hf_models/OpenELM-3B-Instruct/ \\\n",
    "       --outfile models/gguf_models/OpenELM-3B-Instruct-f16.gguf \\\n",
    "       --outtype f16\n",
    "   ```\n",
    "\n",
    "2. **Quantize the model using llama-quantize:**\n",
    "\n",
    "   The quantization process reduces the model's size and computational requirements, which can improve inference speed on resource-constrained devices like the Raspberry Pi. Two types of quantization are demonstrated here:\n",
    "   \n",
    "   - **Q8_0 Quantization:** This reduces the model to 8-bit precision, balancing model size and performance. It typically offers faster inference with a moderate impact on accuracy.\n",
    "   - **Q4_0 Quantization:** This reduces the model further to 4-bit precision, providing greater speed and memory savings at the expense of some accuracy.\n",
    "\n",
    "   For Q8_0 quantization:\n",
    "   ```bash\n",
    "   llama.cpp/build/bin/llama-quantize \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-f16.gguf \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf Q8_0\n",
    "   ```\n",
    "\n",
    "   For Q4_0 quantization:\n",
    "   ```bash\n",
    "   llama.cpp/build/bin/llama-quantize \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-f16.gguf \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-q4_0.gguf Q4_0\n",
    "   ```\n",
    "\n",
    "### Prompting the Model\n",
    "\n",
    "After quantization, you can prompt the different models. For example, to use the Q8_0 quantized model:\n",
    "\n",
    "```bash\n",
    "llama.cpp/build/bin/llama-cli \\\n",
    "    -m models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf \\\n",
    "    -p \"Could you write a very simple program in C++ to print 'Hello, World!' in less than 10 lines of code?\"\n",
    "```\n",
    "\n",
    "Follow similar steps for other prompts or to test the Q4_0 model. This setup process on the Raspberry Pi allows you to benchmark LLM inference on an edge device and later compare performance with an ARM Graviton server.\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "## 2. Setting Up the AWS Arm Graviton Server for Inference Benchmarking\n",
    "\n",
    "If you have not already followed these steps in Lab 2, start by creating an AWS account and logging in as the root user. Next, set up an EC2 instance using a Graviton instance, based on the Arm Neoverse processor by following these steps:\n",
    "\n",
    "1. Search for **EC2** in the AWS Management Console and click on **Launch Instance**.\n",
    "2. Choose your operating system (AMI). Select **Ubuntu** and toggle the architecture box to **arm64**.\n",
    "3. For the instance type, select a **m7g.xlarge** and allocate **32 GB** of persistent storage.\n",
    "4. Launch the instance. Once the instance is created, click **Connect** to get the SSH command. It will look similar to:\n",
    "   ```bash\n",
    "   ssh -i \"your-key.pem\" ubuntu@instance-name.compute.amazonaws.com\n",
    "   ```\n",
    "5. Use the provided SSH command and run it in a terminal to connect to the instance.\n",
    "\n",
    "### Setting Up the Server Environment\n",
    "\n",
    "Once connected:\n",
    "\n",
    "1. Clone this repository:\n",
    "   ```bash\n",
    "   git clone https://github.com/OliverGrainge/Generative_AI_on_arm.git\n",
    "   ```\n",
    "2. Change directory and run the server setup script:\n",
    "   ```bash\n",
    "   cd Generative_AI_on_arm\n",
    "   ./setup_graviton.sh\n",
    "   ```\n",
    "\n",
    "### Building the llama.cpp Inference Framework\n",
    "\n",
    "After setting up the server environment, clone and build the `llama.cpp` framework:\n",
    "\n",
    "1. **Clone the repository:**\n",
    "   ```bash\n",
    "   git clone https://github.com/ggerganov/llama.cpp\n",
    "   ```\n",
    "2. **Configure the build:**\n",
    "   ```bash\n",
    "   cmake -B llama.cpp/build -S llama.cpp -DCMAKE_CXX_FLAGS=\"-mcpu=native\" -DCMAKE_C_FLAGS=\"-mcpu=native\"\n",
    "   ```\n",
    "3. **Compile the framework:**\n",
    "   ```bash\n",
    "   cmake --build llama.cpp/build --config Release -j$(nproc) -v\n",
    "   ```\n",
    "\n",
    "### Downloading the OpenELM-3B Model Weights\n",
    "\n",
    "Assuming you've already created the `download_openelm.py` file from Section 1, proceed with:\n",
    "\n",
    "1. Activate the virtual environment:\n",
    "   ```bash\n",
    "   source graviton_env/bin/activate\n",
    "   ```\n",
    "2. Run the download script:\n",
    "   ```bash\n",
    "   python scripts/download_openelm.py\n",
    "   ```\n",
    "\n",
    "### Converting and Quantizing the Model\n",
    "\n",
    "Once the model has been downloaded:\n",
    "\n",
    "1. **Convert the model to GGUF format:**\n",
    "   ```bash\n",
    "   mkdir models/gguf_models/\n",
    "   python llama.cpp/convert_hf_to_gguf.py models/hf_models/OpenELM-3B-Instruct/ \\\n",
    "       --outfile models/gguf_models/OpenELM-3B-Instruct-f16.gguf \\\n",
    "       --outtype f16\n",
    "   ```\n",
    "\n",
    "2. **Quantize the model:**\n",
    "\n",
    "   For **Q8_0 quantization:**\n",
    "   ```bash\n",
    "   llama.cpp/build/bin/llama-quantize \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-f16.gguf \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf Q8_0\n",
    "   ```\n",
    "\n",
    "   For **Q4_0 quantization:**\n",
    "   ```bash\n",
    "   llama.cpp/build/bin/llama-quantize \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-f16.gguf \\\n",
    "       models/gguf_models/OpenELM-3B-Instruct-q4_0.gguf Q4_0\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "## 3. Benchmarking LLM Inference on Server and Edge\n",
    "\n",
    "\n",
    "Great! If you've completed all the previous steps, you should now have a compiled `llama.cpp` inference framework on both your local Raspberry Pi and a remote ARM Graviton server. Each setup includes the 3B OpenELM model available in floating-point 16 (f16), Int8 (Q8_0), and Int4 (Q4_0) precisions.\n",
    "\n",
    "To compare performance between these devices, we'll calculate key throughput metrics. One valuable metric is the **Prompt Processing Rate**, measured in tokens per second (t/s). This metric indicates how quickly the LLM can process the entire input prompt before producing its first output token. A higher prompt processing rate improves user experience and reflects the model's efficiency in handling large inputs.\n",
    "\n",
    "Another crucial metric is the **Token Generation Rate**, also measured in tokens per second (t/s). During inference, an LLM autoregressively predicts the next token based on the existing context, which includes the prompt and any previously generated tokens. The token generation rate quantifies how quickly these subsequent tokens are produced. This rate can often be improved by leveraging key-value (KV) caching, which reuses previously computed activations to accelerate the prediction of new tokens.\n",
    "\n",
    "Fortunately, `llama.cpp` provides a tool called `llama-bench` to help measure these throughput metrics. For example, to evaluate performance locally using `llama-bench`, you can run:\n",
    "```bash\n",
    "./llama.cpp/build/bin/llama-bench [additional options]\n",
    "```\n",
    "\n",
    "This command will benchmark both the prompt processing and token generation rates, allowing you to compare how the Raspberry Pi and ARM Graviton server handle large language model inference under different configurations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bb762d8c-e180-454a-9a10-81883900e290",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| model                          |       size |     params | backend    | threads |          test |                  t/s |\n",
      "| ------------------------------ | ---------: | ---------: | ---------- | ------: | ------------: | -------------------: |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       4 |           pp4 |         18.27 ± 4.26 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       4 |           tg2 |          4.12 ± 0.80 |\n",
      "\n",
      "build: 1d850433 (4488)\n"
     ]
    }
   ],
   "source": [
    "!llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-q4_0.gguf -p 4 -n 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4845d9ab-d976-4c44-9a1c-342960b943a6",
   "metadata": {},
   "source": [
    "Your output should look like this:\n",
    "\n",
    "| model                          |       size |     params | backend    | threads |          test |                  t/s |\n",
    "| ------------------------------ | ---------: | ---------: | ---------- | ------: | ------------: | -------------------: |\n",
    "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       4 |           pp4 |         21.29 ± 0.23 |\n",
    "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       4 |           tg2 |          5.31 ± 0.26 |\n",
    "\n",
    "build: 1d850433 (4488)\n",
    "\n",
    "In this example, there are two types of tests: **pp4** and **tg2**.\n",
    "\n",
    "- **pp4**: This indicates the prompt processing speed measure in tokens per second. The number `4` in `pp4` represents the 4 input tokens used, specified by the `-p 4` argument passed to `llama-bench`.\n",
    "\n",
    "- **tg2**: This indicates the token generation speed in tokens per second. The number `2` in `tg2` represents the number of tokens generated, specified by the `-n 2` argument passed to `llama-bench`.\n",
    "\n",
    "We can now run a number of experiments. Remember in lab 2, we where able to partition matrix multiplications into different piecies of work, each of them able to be parallelized across KleidiAI microkernels. We can also acchieve this parallelization in the llama.cpp framework by using the --threads argument to the llama-bench tool. Lets setup a benchmark file that will measure the prompt processing and token generation metrics accross different number of threads. You can do that by executing the below script. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6ec2e933-d9e9-466b-940a-53df35d3eea5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting scripts/benchmark_openelm.sh\n"
     ]
    }
   ],
   "source": [
    "%%writefile scripts/benchmark_openelm.sh\n",
    "#!/bin/bash\n",
    "\n",
    "# benchmark the floating point 16 model and write it into \n",
    "mkdir openelm_results\n",
    "llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-q4_0.gguf -p 12 -n 6 --threads 1,2,3,4 | tee openelm_results/q4_pi_results.txt\n",
    "llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf -p 12 -n 6 --threads 1,2,3,4 | tee openelm_results/q8_pi_results.txt \n",
    "\n",
    "# NOTE: we are not benchmarking f16 on Raspberry Pi5 as the benchmark takes too long\n",
    "# llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-f16.gguf -p 12 -n 6 --threads 1,2,3,4 | tee openelm_results/f16_pi_results.txt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74446af5-d62a-4575-9655-098407fa48a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: cannot create directory ‘openelm_results’: File exists\n",
      "| model                          |       size |     params | backend    | threads |          test |                  t/s |\n",
      "| ------------------------------ | ---------: | ---------: | ---------- | ------: | ------------: | -------------------: |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       1 |          pp12 |         11.20 ± 0.20 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       1 |           tg6 |          5.41 ± 0.21 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       2 |          pp12 |         19.65 ± 2.12 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       2 |           tg6 |          5.57 ± 0.27 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       3 |          pp12 |         21.43 ± 1.14 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       3 |           tg6 |          4.91 ± 0.24 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       4 |          pp12 |         22.37 ± 1.38 |\n",
      "| openelm 3B Q4_0                |   1.62 GiB |     3.04 B | CPU        |       4 |           tg6 |          5.12 ± 0.51 |\n",
      "\n",
      "build: 1d850433 (4488)\n",
      "| model                          |       size |     params | backend    | threads |          test |                  t/s |\n",
      "| ------------------------------ | ---------: | ---------: | ---------- | ------: | ------------: | -------------------: |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       1 |          pp12 |          4.81 ± 0.07 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       1 |           tg6 |          3.12 ± 0.14 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       2 |          pp12 |          9.35 ± 0.06 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       2 |           tg6 |          2.99 ± 0.28 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       3 |          pp12 |         13.27 ± 0.32 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       3 |           tg6 |          2.67 ± 0.15 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       4 |          pp12 |         14.03 ± 1.28 |\n",
      "| openelm 3B Q8_0                |   3.01 GiB |     3.04 B | CPU        |       4 |           tg6 |          2.29 ± 0.27 |\n",
      "\n",
      "build: 1d850433 (4488)\n"
     ]
    }
   ],
   "source": [
    "!chmod +x ./scripts/benchmark_openelm.sh\n",
    "!./scripts/benchmark_openelm.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "118511bf-049e-4446-a70c-c2c6354addd8",
   "metadata": {},
   "source": [
    "#### Benchmarking on Graviton\n",
    "\n",
    "Once the above cell finishes, you will have computed the throughput metrics on your Raspberry Pi. Now, we will compute the same metrics on a remote Graviton server for comparison. To do this, we need to create a benchmark script on the remote server that performs the same experiments.\n",
    "\n",
    "Ensure you are connected to the Graviton server via SSH in the terminal. You should have done this in an earlier section when you setup the graviton server. Once you have done that you should open a new script file for benchmarking:\n",
    "\n",
    "```bash\n",
    "nano scripts/benchmark_openelm.sh\n",
    "```\n",
    "\n",
    "Paste the contents of the benchmark script from the provided cell below into this file.\n",
    "```bash\n",
    "#!/bin/bash\n",
    "mkdir openelm_results\n",
    "\n",
    "# benchmark the floating point 16 model and write it into \n",
    "mkdir openelm_results\n",
    "llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-f16.gguf -p 12 -n 6 --threads 1,2,3,4 | tee openelm_results/f16_grav_results.txt \n",
    "llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf -p 12 -n 6 --threads 1,2,3,4 | tee openelm_results/q8_grav_results.txt \n",
    "llama.cpp/build/bin/llama-bench -m models/gguf_models/OpenELM-3B-Instruct-q4_0.gguf -p 12 -n 6 --threads 1,2,3,4 | tee openelm_results/q4_grav_results.txt \n",
    "```\n",
    "To save and exit the file, press `CTRL + O`, then `Enter`, followed by `CTRL + X`.\n",
    "\n",
    "\n",
    "Make the script executable:\n",
    "\n",
    "```bash\n",
    "chmod +x ./scripts/benchmark_openelm.sh\n",
    "```\n",
    "\n",
    "Run the benchmark script:\n",
    "\n",
    "```bash\n",
    "./scripts/benchmark_openelm.sh\n",
    "```\n",
    "\n",
    "Once the script has finished, copy the benchmark results back to your Raspberry Pi for further analysis and comparison:\n",
    "\n",
    "```bash\n",
    "scp -i \"your-key.pem\" -r ubuntu@instance-name.compute.amazonaws.com:your/path/to/Generative_AI_on_arm/openelm_results/ /your/path/to/local/Generative_AI_on_arm/openelm_results/\n",
    "```\n",
    "\n",
    "Now you should have all of the local and server results on your local rasberry pi. Next we should parse those results into a pandas dataframe so that we can plot it easily. We can do that by running the below command. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fb1fbfb7-258d-4887-8789-12dd4183dce6",
   "metadata": {},
   "outputs": [],
   "source": [
    "!python scripts/parse_results.py openelm_results/q8_pi_results.txt\n",
    "!python scripts/parse_results.py openelm_results/q4_pi_results.txt\n",
    "\n",
    "!python scripts/parse_results.py openelm_results/f16_grav_results.txt\n",
    "!python scripts/parse_results.py openelm_results/q8_grav_results.txt\n",
    "!python scripts/parse_results.py openelm_results/q4_grav_results.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51195633-5314-498f-926c-9945d743d2af",
   "metadata": {},
   "source": [
    "Lets now load those pandas dataframes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "deca2eb1-aacb-4da0-ab18-52846cc9c026",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "\n",
    "df_pi_q8 = pd.read_csv(\"openelm_results/q8_pi_results.csv\")\n",
    "df_pi_q4 = pd.read_csv(\"openelm_results/q4_pi_results.csv\")\n",
    "\n",
    "df_grav_f16 = pd.read_csv(\"openelm_results/f16_grav_results.csv\")\n",
    "df_grav_q8 = pd.read_csv(\"openelm_results/q8_grav_results.csv\")\n",
    "df_grav_q4 = pd.read_csv(\"openelm_results/q4_grav_results.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4da3312-21d2-46f8-9219-706b5bf0e592",
   "metadata": {},
   "source": [
    "Now we have done that we should have a look at prompt processing throughput  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1ccb000a-95b5-4ab7-a0de-0895c728abae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Filter data for tests starting with 'pp'\n",
    "filtered_dfs = {\n",
    "    \"PI Q8\": (df_pi_q8, 'blue', 'o', '-'),\n",
    "    \"PI Q4\": (df_pi_q4, 'red', 'o', '-'),\n",
    "    \"Grav F16\": (df_grav_f16, 'green', 'd', '--'),\n",
    "    \"Grav Q8\": (df_grav_q8, 'blue', 'd', '--'),\n",
    "    \"Grav Q4\": (df_grav_q4, 'red', 'd', '--'),\n",
    "}\n",
    "\n",
    "# Function to plot speed vs threads\n",
    "def plot_speed_vs_threads(df, label, color, marker, linestyle):\n",
    "    filtered_df = df[df['Test'].str.startswith('pp')]\n",
    "    plt.plot(filtered_df['Threads'], filtered_df['Speed (t/s)'], \n",
    "             label=label, marker=marker, color=color, linestyle=linestyle)\n",
    "\n",
    "# Plot each dataset\n",
    "for label, (df, color, marker, linestyle) in filtered_dfs.items():\n",
    "    plot_speed_vs_threads(df, label, color, marker, linestyle)\n",
    "\n",
    "plt.xlabel('Threads')\n",
    "plt.ylabel('Speed (t/s)')\n",
    "plt.title('Threads vs Prefill Speed (t/s) for Different Configurations')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f136d60-0e54-4126-bcd3-d97c1d7c56a6",
   "metadata": {},
   "source": [
    "### **Graph Analysis: Thread Scaling and Bottlenecks**\n",
    "\n",
    "This graph highlights key differences in how **thread count impacts throughput (tokens per second) during the prompt processing stage** for the Raspberry Pi and Graviton systems.\n",
    "\n",
    "For **Graviton** (dashed lines), you should observe an almost perfect **linear increase in throughput** as the thread count increases, across all precision levels. This strongly suggests that **prompt processing is compute-bound rather than memory-bound** on Graviton. In other words, the primary bottleneck is the **computational workload** (such as multiply-add-accumulate operations) rather than memory access latency.\n",
    "\n",
    "In contrast, for the **Raspberry Pi** (solid lines), throughput improvements become **sublinear** as more threads are added. This indicates that the **computation becomes memory-bound**, meaning the processor is increasingly limited by memory access speeds rather than raw compute power. The **Raspberry Pi 5 has only four CPU cores**, and its memory system becomes a bottleneck as more threads compete for bandwidth.\n",
    "\n",
    "The key reason for this difference lies in the **memory architecture and cache hierarchy** of the two systems. The Raspberry Pi has **much smaller caches**, forcing it to access **slower system memory more frequently**, introducing latency and reducing efficiency. In contrast, the **Graviton server features larger and faster caches**, which can sustain the high memory bandwidth demands of the **3B model**, avoiding major slowdowns as thread count increases.\n",
    "\n",
    "Additionally, if we look at the **single-threaded performance** (where the **x-axis = 1**), we can see that the **Graviton server achieves significantly higher throughput than the Raspberry Pi**, even before scaling up with additional threads. This advantage is not only due to the **higher clock speed** of the Graviton CPU but also the presence of **specialized ARM CPU extensions** that the Raspberry Pi lacks. As covered in **Lab 2**, the Graviton processor includes **DotProd (Dot Product) and I8MM (Integer Matrix Multiplication) instructions**, which accelerate deep learning computations by optimizing tensor operations at the hardware level. These **optimized instructions enable more efficient matrix multiplications**, a key operation in transformer-based models, giving Graviton an edge even in single-threaded execution.\n",
    "\n",
    "This distinction between **compute-bound vs. memory-bound performance**, along with the impact of **hardware-level optimizations**, highlights the scalability and efficiency differences between embedded ARM devices and high-performance ARM servers when running transformer-based models. 🚀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "da73b9fa-2ce9-4511-8476-8e7b92103a91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define dataset mappings with color, marker, and linestyle\n",
    "filtered_dfs = {\n",
    "    \"PI Q8\": (df_pi_q8, 'blue', 'o', '-'),\n",
    "    \"PI Q4\": (df_pi_q4, 'red', 'o', '-'),\n",
    "    \"Grav F16\": (df_grav_f16, 'green', 'd', '--'),\n",
    "    \"Grav Q8\": (df_grav_q8, 'blue', 'd', '--'),\n",
    "    \"Grav Q4\": (df_grav_q4, 'red', 'd', '--'),\n",
    "}\n",
    "\n",
    "# Function to plot speed vs threads\n",
    "def plot_speed_vs_threads(df, label, color, marker, linestyle):\n",
    "    filtered_df = df[df['Test'].str.startswith('tg')]\n",
    "    plt.plot(filtered_df['Threads'], filtered_df['Speed (t/s)'], \n",
    "             label=label, marker=marker, color=color, linestyle=linestyle)\n",
    "\n",
    "# Loop through datasets and plot\n",
    "for label, (df, color, marker, linestyle) in filtered_dfs.items():\n",
    "    plot_speed_vs_threads(df, label, color, marker, linestyle)\n",
    "\n",
    "plt.xlabel('Threads')\n",
    "plt.ylabel('Speed (t/s)')\n",
    "plt.title('Threads vs Token Generation Speed (t/s) for Different Configurations')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24101e3-4cbe-4971-82f9-f3931f3318a0",
   "metadata": {},
   "source": [
    "### **Graph Analysis: Token Generation Throughput and Bottlenecks**\n",
    "\n",
    "In this graph, we observe that **token generation throughput on the Graviton server scales linearly with the number of processing threads**. This suggests that **token generation on Graviton is again compute-bound**, meaning that performance is primarily limited by operation throughput rather than memory access.\n",
    "\n",
    "For the **Raspberry Pi**, however, you should see that the throughput (speed (t/s) on the graph) remains relatively **flat**, showing little to no improvement as additional threads are added.\n",
    "\n",
    "The key reason for this difference lies in the computational intensity of these two phases:\n",
    "\n",
    "- **Prompt processing is highly arithmetic-intensive**, as it requires computing attention across the entire input sequence at once. Each token in the prompt is processed **in parallel**, leading to a large number of floating-point operations per second (**FLOPS**) or tera operations per second (**TOPS**).\n",
    "- **Token generation, in contrast, is inherently sequential**, with only **one token being generated at a time**. Thanks to the **key-value (KV) cache**, the transformer does not need to recompute attention over all previous tokens from scratch. Instead, it **only retrieves stored key and value activations** from earlier steps and computes attention over them. This significantly **reduces the number of arithmetic operations per token**, making token generation far less compute-intensive than prompt processing.\n",
    "\n",
    "Because the **feed-forward layers in the transformer process each new token independently**, the overall FLOPS/TOPS demand is lower than in the prefill phase. However, token generation introduces **a higher ratio of memory reads to arithmetic operations**:\n",
    "- The model must **fetch previously stored key-value activations** for attention calculations.\n",
    "- It must also **load the neural network’s weights** to compute the feed-forward layers.\n",
    "- As a result, **memory bandwidth becomes a key factor** in determining performance.\n",
    "\n",
    "On **Graviton**, with its **higher memory bandwidth**, token generation remains **compute-bound**, as indicated by the continued increase in throughput with additional threads. The processor can efficiently fetch and process key-value activations while keeping arithmetic units fully utilized.\n",
    "\n",
    "On the **Raspberry Pi**, however, memory bandwidth is significantly more constrained. Since token generation involves frequent memory accesses to retrieve cached activations, the system quickly becomes **memory-bound**. This explains why **adding more threads does not improve performance**—the bottleneck is not compute power but rather the ability to access memory quickly enough to feed the processor.\n",
    "\n",
    "---\n",
    "\n",
    "## 4. **Hands-on LLM Interaction**\n",
    "\n",
    "To fully appreciate the difference in performance between the Raspberry Pi and the Graviton server, you should **interact with the models directly**.\n",
    "\n",
    "#### **Running the Model Locally**\n",
    "On your **Raspberry Pi**, open a terminal and run the following command:\n",
    "\n",
    "```bash\n",
    "llama.cpp/build/bin/llama-cli -m models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf -cnv --chat-template chatml\n",
    "```\n",
    "\n",
    "At the same time, run the same command in your **SSH session connected to the Graviton server**:\n",
    "\n",
    "```bash\n",
    "llama.cpp/build/bin/llama-cli -m models/gguf_models/OpenELM-3B-Instruct-q8_0.gguf -cnv --chat-template chatml\n",
    "```\n",
    "\n",
    "#### **Things to Observe**\n",
    "- **Response Speed**: Notice the difference in how quickly tokens are generated on each system.\n",
    "- **Smoothness of Interaction**: Pay attention to delays when asking follow-up questions.\n",
    "- **Effect of Precision**: Try modifying the model precision by changing the `-m` argument to a different quantized version (e.g., `q4_0` or `f16`) and see how it impacts performance.\n",
    "\n",
    "By running the model on both platforms, you will get a **practical, hands-on understanding** of how compute-bound vs. memory-bound constraints impact real-world inference performance. \n",
    "\n",
    "Feel free to experiment with different model configurations and report your observations! 🚀\n",
    "\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ae03bb4-c94a-4c6a-8407-594a7c67128c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96e3e1c4-df1b-4426-8bfd-c36db48890c9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a939ab5f-de39-449d-a159-97496956cba0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}