abelardojarab

import numpy as np
import multiprocessing.shared_memory as shm
from concurrent.futures import ProcessPoolExecutor, as_completed
import ray
import contextlib

class ParallelArrayProcessor:
    def __init__(self, data, num_chunks=8, use_shared_memory=False):
        """
        Initialize processor.

abelardojarab

import collections
import json
import re
import concurrent.futures

def _create_default_tree():
    return [0, collections.defaultdict(dict)]

def process_trace_chunk(trace_chunk):
    """Processes a subset of kernel traces and returns a local stack tree."""

abelardojarab

import collections
import json
import re
import ray
import graphviz

ray.init(ignore_reinit_error=True)

@ray.remote
class StackProcessor:

abelardojarab

import collections
import json
import re
import graphviz

class KernelFlameGraph:
    def __init__(self):
        # Nested structure for stack hierarchy (FlameGraph format)
        self.stack_tree = collections.defaultdict(lambda: [0, collections.defaultdict(dict)])
        # Flat dictionary to track accumulated occurrences of each function

abelardojarab

from concurrent.futures import ProcessPoolExecutor
from collections import Counter
import os
#import psutil
import re

def map_word_count(text_chunk):
    """Map function: Counts words in a chunk of text."""
    words = re.findall(r'\w+', text_chunk.lower())  # Tokenize words
    return Counter(words)  # Return word frequencies

abelardojarab

Data Splitting and Reduction Techniques in Python and NumPy

1. Introduction

Efficiently splitting data structures and performing reduce operations are essential skills for optimizing computations in Python, especially for interviews. This document covers:

• Splitting lists, dictionaries, and matrices using Python and NumPy
• Common reduce operations for 1D and 2D data

---

2. Splitting Data Structures

abelardojarab

Parallel Computation: Task Execution, ProcessPoolExecutor, and Ray for Matrix Multiplication

Introduction

Parallel execution is essential for optimizing computational workloads such as matrix multiplication, large-scale data processing, and distributed computing. In this document, we explore:

1. Creating a Generalized Task Execution Framework
2. Using ProcessPoolExecutor and Ray for 1D and 2D Task Execution
3. Parallel Matrix Multiplication (Stripe-Based vs. Block-Based Approaches)

---

abelardojarab

Complete Guide to Parallel Processing in Python

Table of Contents

1. Queue Types
2. ProcessPoolExecutor: Map and Submit
3. Matrix Operations
4. MapReduce Implementation
5. Roofline Model Analysis
6. Function Event Tracking
7. Ray for Distributed Computing

abelardojarab

import numpy as np
import multiprocessing
from concurrent.futures import ProcessPoolExecutor

def process_chunk(chunk, chunk_start_idx):
    """Processes a chunk of samples and tracks function lifetimes."""
    active_functions = {}  # {function_name: start_time}
    events = []

    for offset, functions in enumerate(chunk):

abelardojarab

#include <iostream>
#include <unordered_map>
#include <vector>
#include <queue>
#include <stack>
#include <unordered_set>

class Graph {
private:
  std::unordered_map<int, std::vector<int>> adjList;