Understanding a Scientist's Tools Outside the Lab
PhyComm
What this talk is not
- How to code
- How to how to code
- What to use to code
What this talk will cover
- What is an instruction
- How do CPUs execute instructions?
- How does computer memory work?
- How can I practically use this information?
Let's familiarize ourselves by example
def f():
print("Hello world")
f()sh-5.1$ python3 example_1.py
Hello World
Let's familiarize ourselves by example
import dis
def f():
print("Hello World")
dis.dis(f)
sh-5.1$ python3 example_2.py
4 0 LOAD_GLOBAL 0 (print)
2 LOAD_CONST 1 ('Hello World')
4 CALL_FUNCTION 1
6 POP_TOP
8 LOAD_CONST 0 (None)
10 RETURN_VALUELet's familiarize ourselves by example
#include <stdio.h>
int main() {
printf("Hello World!\n");
return 0;
}
sh-5.1$ gcc -S example_3.c
sh-5.1$ cat example_3.s
.file "example_3.c"
.text
.section .rodata
.LC0:
.string "Hello World!"
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $.LC0, %edi
call puts
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (GNU) 12.1.1 20220507 (Red Hat 12.1.1-1)"
.section .note.GNU-stack,"",@progbits
The first step: instructions
Python's Instruction Set: Bytecode
- An intermediary "computer" - The Python VM
- Variations - CPython, Jython, PyPy, etc.
- But not the only one
import dis.dis
def main():
l = [1, 2, 3]
return l[2]
dis.dis(main)
sh-5.1$ python3 example_4.py
4 0 BUILD_LIST 0
2 LOAD_CONST 1 ((1, 2, 3))
4 LIST_EXTEND 1
6 STORE_FAST 0 (l)
5 8 LOAD_FAST 0 (l)
10 LOAD_CONST 2 (2)
12 BINARY_SUBSCR
14 RETURN_VALUE
Your CPU's (likely) Instruction Set: AMD64 (aka x86_64)
- Much much more complex, and not worth your time
- What is worth your time: Understanding how your CPU uses them
- Load into memory
- Read a "word" from memory
- Decode what that word means
- Run the code
The clock cycle
But how did the code get in the memory?
The next level of abstraction: The Kernel
- Stands between the hardware and software
- Handles exchange of data between them
- Handles memory allocation
- Lets take a look at mine!
Something actually useful: JIT Compilation
- Compile when needed and cache
- Example - Julia and PyPy
- Here's some benchmarks
Something actually useful: CPU Caching
- Recently read words from memory are cached in your CPU Cache
- Fetching from memory is slower than reading from cache
- Moral of the story: Keep objects in cache while you want to act on them
Something actually useful: Reading this article!
https://viralinstruction.com/posts/hardware/
Something not useful but fun: Listen to your RAM!
$ aplay /dev/mem
Thanks for listening! Questions?
Telegram: t.me/cocoa1231
Email: cocoathepenguin@protonmail.com
Understanding a Scientist's Tools Outside the Lab
By cocoa1231
