boywitharupee

is this mainly about making host binaries self-contained for heterogenous workloads?

also, seems like this is mostly targeted towards HPC audience?

is it this? https://github.com/janestreet/incremental

You can denoise it: https://github.com/google/security-research/security/advisor...

> has been looping indefinitely

this can mean WebContent process is crashing

the timer and urgency of this reminds me of the movie Armageddon where they had limited time to form a crew for a space mission.

they have a watchdog loop, it runs periodically

shouldn't the title be "CUDA Tile IR Open Sourced"?

is there a document or reference implementation that describes the full algorithm? tiling, sorting, merging, and strip conversion.

> In C++, it's an rvalue reference , which can be effectively thought of as an lvalue

hmm...this doesn't sound quite right? the comma operator's result in C++ is not an rvalue reference - it takes on exactly the value category of its right operand (which in this case is an lvalue)

so, these are hand optimized primitives for specific model of nvidia gpus? do you still have to make launch/scheduling decisions to maximize occupancy? how does this approach scale to other target devices with specialized instruction sets and different architecture?

can someone explain how is profiling tools like this written for GPU applications? wouldn't you need access to internal runtime api?

for ex. Apple wraps Metal buffers as "Debug" buffers to record allocations/deallocations.

what kind of model architecture was used for this? is it safe to assume they used a transformer model or a variant of it?

what's the purpose of this? is it one of those 'fun' problems to solve?

how different is this compared to Facebook's open-source tool Faiss[1]?

[1] https://github.com/facebookresearch/faiss/

In a similar fashion, you'll see that JAX has frontend code being open-sourced, while device-related code is distributed as binaries. For example, if you're on Google's TPU, you'll see libtpu.so, and on macOS, you'll see pjrt_plugin_metal_1.x.dylib.

The main optimizations (scheduler, vectorizer, etc.) are hidden behind these shared libraries. If open-sourced, they might reveal hints about proprietary algorithms and provide clues to various hardware components, which could potentially be exploited.

or have the right entitlements?

https://developer.apple.com/documentation/bundleresources/en...

> At runtime, C&P generates executable code by copying the object code and patching the holes with runtime known values.

how would this work on OSs under hardened runtime rules?

will you also provide compute resources?

how would you compare this to the polytope model? https://en.wikipedia.org/wiki/Polytope_model

and is Griffin a state space model?

i wonder if we can train a foundational model on this data which will eventually allow to semantically search the codebase?

what's the memory and compute requirements for this?

but which model to tokenize with? is there a leaderboard for models that are good for RAG?

is this known as a procedural generation?

care to explain why attention has precision issues with fp8?

the title seems like a misnomer.

shouldn't this be "python 3.13 gets a new jit compiler" because python already has a jit.

JAX is a wrapper on top of XLA. Instead of writing pure python, you're writing JAX abstractions.

for ex, a simple loop in JAX:

  def solve(i, v): return i+v
  x = jax.lax.fori_loop(0, 5, solve, 10)

> what the Komoglorov complexity of "NSFW GLSL Content" is

can you explain what you mean by above?

currently, on apple silicon "GPU" <> "Metal" are synonymous.

yes, there are other apis (opengl,opencl) to access the gpu but they're all deprecated.

technically, yes, this is using Metal.

in tinygrad, the llama2 model with Metal runtime produces 1k kernels. this means we have to compile them all, leading to both startup and runtime costs from repeated compilations and buffer bindings. someone suggested using one megakernel to call the rest. could dynamic partitioning help here?