• repos
• papers
• books
• blags

angr's power comes not from it being an emulator, but from being able to execute with what we call symbolic variables.

potential target for low latency (or sparse?) stuff

gonna need this sooner or later

just useful for learning about BB (what about interior point?)

is this the actual basis of PIP?

for hackerrank interviews...

can i use this for a better python ast? also https://plugins.jetbrains.com/docs/intellij/psi.html

implement for CIRCT?

Circle is a C++ bare metal programming environment for the Raspberry Pi.

basically does rewrite on import which enables python files to host alternative syntax. kind of cute but not really what i want

static memory allocation problem can be formulated as LRA opt + XOR? also https://optimathsat.disi.unitn.it/.

not sure

Chunky Loop Analyzer: A Polyhedral Representation Extraction Tool for High Level Programs

compiling is annoying af

• python bindings
• use clan to analyze python for loops

A Next-Generation Compiler Compiler

• use it to parse python into MLIR (using mll)

• extract the BDD and combine with PIP

• use the python frontend to lower to affine

if i'm gonna solve things symbolically (ie DSA) this might be useful

just take for a test drive

use in combination with yices?

how is it different from ISL? sage bindings?. also python bindings

can this solve DSA?

somewhere in here there's an implementation of a PIP solver

Polyhedral projection is a main operation of the polyhedron abstract domain. It can be computed via parametric linear programming (PLP), which is more efficient than the classic Fourier-Motzkin elimination method.

^ hmm is that really true? i thought one relied on the other?

related to this paper (An efficient parametric linear programming solver and application to polyhedral projection)

A naive implementation of the Gomory cutting plane algorithm

is this faster than solving the CSP?

The basic concept is to get the normal compiler front end like clang to emit its LLVM Intermediate Representation (IR) as a bitcode file, then run a custom LLVM pass over this to inject DRTI code at the appropriate places.

also https://software.cs.uni-koeln.de/scil/documentation/html/main.html

We present a novel algorithm for finite domain constraint optimization that generalizes branch-and-bound search by reasoning about sets of assignments rather than individual assignments.

the next step of the low latency work

don't quite understand this but symbolic virtual machine is what i need for various parts of the static memory planning thing

faster way to solve PIPs?

approx method for solving ILPs (learning). probably not that easy to implement (gym env?)

approx method for solving ILPs (learning). probably easy to prototype using xgboost

isl official tutorial (read after completing pollylabs tuts)

Interestingly, AlphaTensor finds algorithms with a larger number of additions compared with Strassen-square (or equivalently, denser decompositions), but the discovered algorithms generate individual operations that can be efficiently fused by the specific XLA33 grouping procedure and thus are more tailored towards the compiler stack we use.

implement in CIRCT

maybe this can be done using or-tools?

maybe this can be done with https://github.com/siala/Hybrid-Mistral

just good to know

can this solve the DSA problem?

just good to know

implement in CIRCT

read after learning racket

racket class on implementing small languages

probably useful for lockfree?

just good to know

required reading but i'll probably never get to it?

required reading but i'll probably never get to it?

definitely need to know this for HFT

suitable allocation algo for nns?

re the MLIR pass plugin project. also https://developer.ibm.com/tutorials/l-dynamic-libraries/

maybe for bare metal arm but also maybe bare metal gpu

this is the next stage of the low latency project

also https://forums.developer.nvidia.com/t/boosting-inline-packet-processing-using-dpdk-and-gpudev-with-gpus/212943)) and Benchmarking GPUDirect RDMA on Modern Server Platforms

can this solve the DSA problem?

should probably know this after teaching rohan

learn in order to use rust a compiler. another source.

read in prep for luminous

some useful discussion on symbolic autodiff

useful for ... everything?

probably inflated but worth a read

compile MLIR to wasm in order to run in browser? maybe that's useless and just use torch-mlir wheels

hack pcie to get lower than 0.5us latency

cs.theory discussing how presburger formulas actually work - including some discussion of BDDs