Hyper Functions for Parallel Execution in Carbon

[1strewave]

Proposal: Hyper Functions for Parallel Execution in Carbon

Introduction

Hey there! First of all, thanks for developing Carbon it's an exciting language with great potential. I have an idea to improve performance in specific code sections by enabling parallel execution with additional threads.

Presenting: Hyper Functions (Not from Math)

package Sorting;

fn Partition[T:! Comparable & Movable](s: Slice(T)) -> i64 {
    var i: i64 = -1;
    hyper {
        for (e: T in s) {
            if (e <= s.Last()) {
                i++;
                Swap(&s[i], &e);
            }
        }
    }
    return i;
}

fn QuickSort[T:! Comparable & Movable](s: Slice(T)) {
    if (s.Size() <= 1) {
        return;
    }
    let p: i64 = Partition(s);
    QuickSort(s[:p - 1]);
    QuickSort(s[:p + 1]);
}

What Are Hyper Functions?

Hyper Functions provide a way to boost efficiency in small, computationally expensive code sections by utilizing additional threads dynamically.

When you mark a block with hyper, the compiler will allocate more threads to parallelize execution where possible. This can be particularly useful for optimizing bottlenecks, such as sorting, numerical operations, or other performance-sensitive tasks.

Why Hyper Functions?

• Fine-Grained Parallelism: Instead of parallelizing an entire function, hyper lets developers optimize just the most critical sections.
• Better Performance: By focusing additional resources only where needed, Hyper Functions can help reduce execution time without overloading the system.
• Simplicity: No need for explicit thread management—the compiler decides how best to distribute the workload.

I’d love to hear your thoughts on this idea and whether it could fit within Carbon’s concurrency model!

[geoffromer]

I’d love to hear your thoughts on this idea and whether it could fit within Carbon’s concurrency model!

I'm afraid it's too early to say. Work on Carbon-native concurrency is deferred until at least the 0.2 milestone.