- The document discusses the process of forking and creating new processes in an operating system. It describes the key steps like allocating memory for the child process, copying resources from the parent, and starting the new process.
- Code examples are provided to demonstrate how fork is implemented at the system call level and how it is used in C programs to create new threads.
- The document also explains the data structures and functions involved in process switching and context switching between threads.
This document compares and contrasts Clojure and Elixir programming languages. It provides an overview of their origins, syntax, concurrency models, macro systems, and further reading recommendations. Key points include Clojure running on the JVM while Elixir runs on the BEAM VM, both having Lisp-like syntax with differences in collection types, and both supporting metaprogramming through macros while having different macro expansion approaches.
The document summarizes the use of LLVM for code generation when recompiling Nintendo games as native games. LLVM provides a full compiler infrastructure that can be used to generate code for various platforms from a common intermediate representation (LLVM bitcode). The document discusses using LLVM for code generation from 6502 assembly to generate native code for emulation. Optimizations available through LLVM are also discussed.
- The document discusses the process of forking and creating new processes in an operating system. It describes the key steps like allocating memory for the child process, copying resources from the parent, and starting the new process.
- Code examples are provided to demonstrate how fork is implemented at the system call level and how it is used in C programs to create new threads.
- The document also explains the data structures and functions involved in process switching and context switching between threads.
This document compares and contrasts Clojure and Elixir programming languages. It provides an overview of their origins, syntax, concurrency models, macro systems, and further reading recommendations. Key points include Clojure running on the JVM while Elixir runs on the BEAM VM, both having Lisp-like syntax with differences in collection types, and both supporting metaprogramming through macros while having different macro expansion approaches.
The document summarizes the use of LLVM for code generation when recompiling Nintendo games as native games. LLVM provides a full compiler infrastructure that can be used to generate code for various platforms from a common intermediate representation (LLVM bitcode). The document discusses using LLVM for code generation from 6502 assembly to generate native code for emulation. Optimizations available through LLVM are also discussed.
This document discusses how Qemu works to translate guest binaries to run on the host machine. It first generates an intermediate representation called TCG-IR from the guest binary code. It then translates the TCG-IR into native host machine code. To achieve high performance, it chains translated blocks together by patching jump targets. Key techniques include just-in-time compilation, translation block finding, block chaining, and helper functions to emulate unsupported guest instructions.
The document discusses how a "Hello World" program works behind the scenes. It covers topics like compilation, linking, executable file formats, loading programs into memory, and process creation. The key points are:
1) A C program is compiled into an object file, then linked with library files to create an executable. The linker resolves symbols and relocates addresses.
2) Executable files use formats like ELF that contain machine code, data, symbol tables, and sections. Object files have a similar format.
3) When a program runs, the OS loads pages of the executable into memory as needed and sets up the process with its own virtual address space.
4) System calls
Kernel Recipes 2015: Linux Kernel IO subsystem - How it works and how can I s...Anne Nicolas
Understanding how Linux kernel IO subsystem works is a key to analysis of a wide variety of issues occurring when running a Linux system. This talk is aimed at helping Linux users understand what is going on and how to get more insight into what is happening.
First we present an overview of Linux kernel block layer including different IO schedulers. We also talk about a new block multiqueue implementation that gets used for more and more devices.
After surveying the basic architecture we will be prepared to talk about tools to peek into it. We start with lightweight monitoring like iostat and continue with more heavy blktrace and variety of tools that are based on it. We demonstrate use of the tools on analysis of real world issues.
Jan Kara, SUSE
This document contains code and descriptions related to the MIPS architecture and LLVM compiler infrastructure. It includes MIPS assembly code, the definition of MIPS registers and instructions as LLVM IR, descriptions of the MIPS instruction formats and functional units, and MIPS instruction itineraries. It also contains x86/AVX-512 intrinsics and builtins.
The document describes the DWARF debugging format specification. It includes sections for debug_info, debug_abbrev, debug_line, debug_frame, and debug_aranges. The debug_info section contains compilation unit headers and debugging information entries. The debug_abbrev section contains abbreviation declarations that specify tags and attributes for debugging information entries. The debug_frame section contains Call Frame Information including CIE and FDE entries that describe how registers are saved and restored by procedures.
The document discusses register allocation in LLVM. It begins with an introduction to the register allocation problem and describes LLVM's base register allocation interface. It then provides more details on LLVM's basic register allocation approach and its greedy register allocation approach. The greedy approach uses techniques like live range splitting to improve register allocation.
The document provides an overview of eBPF maps and how they can be used to share data between eBPF programs running in the kernel and userspace applications. It describes how maps are created via the BPF syscall using the BPF_MAP_CREATE command. It also explains how keys and values can be looked up, updated, and deleted from maps using commands like BPF_MAP_LOOKUP_ELEM, BPF_MAP_UPDATE_ELEM, and BPF_MAP_DELETE_ELEM. Finally, it lists the different types of eBPF maps available.
The "n" in the PrintCompilation output indicates that the method was not compiled, but is on deck to be compiled. So in this case, java.lang.Object::hashCode was not yet compiled, but is a candidate for compilation if/when it is called more.
The code compares pointers and arrays in C by printing their sizes and string lengths. When a string literal is assigned to a pointer, sizeof(pointer) returns the pointer size rather than the string length, while sizeof(array) returns the full array size including the null terminator. strlen(pointer) and strlen(array) both return the string length excluding the null terminator. When an array is passed to a function, it converts to a pointer and sizeof then returns the pointer size rather than full array size.
This document discusses how Qemu works to translate guest binaries to run on the host machine. It first generates an intermediate representation called TCG-IR from the guest binary code. It then translates the TCG-IR into native host machine code. To achieve high performance, it chains translated blocks together by patching jump targets. Key techniques include just-in-time compilation, translation block finding, block chaining, and helper functions to emulate unsupported guest instructions.
The document discusses how a "Hello World" program works behind the scenes. It covers topics like compilation, linking, executable file formats, loading programs into memory, and process creation. The key points are:
1) A C program is compiled into an object file, then linked with library files to create an executable. The linker resolves symbols and relocates addresses.
2) Executable files use formats like ELF that contain machine code, data, symbol tables, and sections. Object files have a similar format.
3) When a program runs, the OS loads pages of the executable into memory as needed and sets up the process with its own virtual address space.
4) System calls
Kernel Recipes 2015: Linux Kernel IO subsystem - How it works and how can I s...Anne Nicolas
Understanding how Linux kernel IO subsystem works is a key to analysis of a wide variety of issues occurring when running a Linux system. This talk is aimed at helping Linux users understand what is going on and how to get more insight into what is happening.
First we present an overview of Linux kernel block layer including different IO schedulers. We also talk about a new block multiqueue implementation that gets used for more and more devices.
After surveying the basic architecture we will be prepared to talk about tools to peek into it. We start with lightweight monitoring like iostat and continue with more heavy blktrace and variety of tools that are based on it. We demonstrate use of the tools on analysis of real world issues.
Jan Kara, SUSE
This document contains code and descriptions related to the MIPS architecture and LLVM compiler infrastructure. It includes MIPS assembly code, the definition of MIPS registers and instructions as LLVM IR, descriptions of the MIPS instruction formats and functional units, and MIPS instruction itineraries. It also contains x86/AVX-512 intrinsics and builtins.
The document describes the DWARF debugging format specification. It includes sections for debug_info, debug_abbrev, debug_line, debug_frame, and debug_aranges. The debug_info section contains compilation unit headers and debugging information entries. The debug_abbrev section contains abbreviation declarations that specify tags and attributes for debugging information entries. The debug_frame section contains Call Frame Information including CIE and FDE entries that describe how registers are saved and restored by procedures.
The document discusses register allocation in LLVM. It begins with an introduction to the register allocation problem and describes LLVM's base register allocation interface. It then provides more details on LLVM's basic register allocation approach and its greedy register allocation approach. The greedy approach uses techniques like live range splitting to improve register allocation.
The document provides an overview of eBPF maps and how they can be used to share data between eBPF programs running in the kernel and userspace applications. It describes how maps are created via the BPF syscall using the BPF_MAP_CREATE command. It also explains how keys and values can be looked up, updated, and deleted from maps using commands like BPF_MAP_LOOKUP_ELEM, BPF_MAP_UPDATE_ELEM, and BPF_MAP_DELETE_ELEM. Finally, it lists the different types of eBPF maps available.
The "n" in the PrintCompilation output indicates that the method was not compiled, but is on deck to be compiled. So in this case, java.lang.Object::hashCode was not yet compiled, but is a candidate for compilation if/when it is called more.
The code compares pointers and arrays in C by printing their sizes and string lengths. When a string literal is assigned to a pointer, sizeof(pointer) returns the pointer size rather than the string length, while sizeof(array) returns the full array size including the null terminator. strlen(pointer) and strlen(array) both return the string length excluding the null terminator. When an array is passed to a function, it converts to a pointer and sizeof then returns the pointer size rather than full array size.
Eitaro Fukamachi presents CL21, a redesign of Common Lisp for the 21st century. CL21 aims to improve Common Lisp's consistency, expressiveness, compatibility, and efficiency. It focuses on simplifying naming conventions, removing unnecessary symbols, and making the language more suitable for modern use while maintaining 100% compatibility with Common Lisp code and libraries. The project is still in development with discussions ongoing about final syntax and standard library decisions. CL21 hopes to make Lisp a premier language for prototyping by building on Common Lisp's strengths.
AI and Machine Learning Demystified by Carol Smith at Midwest UX 2017Carol Smith
What is machine learning? Is UX relevant in the age of artificial intelligence (AI)? How can I take advantage of cognitive computing? Get answers to these questions and learn about the implications for your work in this session. Carol will help you understand at a basic level how these systems are built and what is required to get insights from them. Carol will present examples of how machine learning is already being used and explore the ethical challenges inherent in creating AI. You will walk away with an awareness of the weaknesses of AI and the knowledge of how these systems work.
About how to make a Website. I used this for Women Who Code Tokyo(http://www.meetup.com/Women-Who-Code-Tokyo/)'s meetup. It's would be glad if it could help someone.