msullivan / he-man Goto Github PK

Can we reduce the size of the thread structs?

• Observable sharing to limit code duplication.
• Add function calls for shared functionality.
• Add more primitives to front-end language.
• Add high-level support for common C operations (string manipulation, etc.).
• Allow communication between threads. (Channel model? Shared buffers? Semantics?)

• Reduce memory footprint of struct thread_t.
• Use slab allocator instead of malloc.
• Multithreaded runtime?

Block-local:

• Constant propagation
• RelnOp constant folding
• Copy propagation (to reduce closure size)

Global:

• Hoist blocks with unique jump targets
• Hoist inconsequential (e.g., close and exit) blocks.
• Hoist GotoWait blocks.

More and better benchmarking. Use PlanetLab? Compare with:

• Zdancewic, Peng code.
• Apache.
• nginx, lighttpd, or other native event-loop servers.
• Handwritten code, or other code which we directly port to He-Man.

Currently, threads track the events that they created and when they exit, free the events and the associated file descriptors. Same with buffers. This is kind of lame, since it means that you can't hand events/buffers to newly created threads. On the other hand, it's a really easy way to automatically clean up the events/buffers/

Inline non-blocking code blocks, to avoid yielding for simple block-internal control flow.

Removes:

• empty while loops
• empty threads
• empty GotoWait destinations

Use phantom types, GADTs, etc. to allow type-checking the front-end language (by Haskell). Would be ideal if it was impossible to output C code which fails to compile.

Add a pure Haskell implementation of the front-end language (cf Zdancewic, Peng).

In the codegen, we hard code the variable name for new threads to be "new_thread", so if you spawn more than one thread in a block, it eats shit.

Expected behavior: backend not crashing

Actual behavior:

: Language/HeMan/Backend.hs:364:7-67: Irrefutable pattern failed for pattern ([fromBlock], bs'')