Lecture 1: Course Introduction and Overview

Lecture 1: Course Introduction and Overview

CS162 Operating Systems and Systems Programming Lecture 5 Introduction to Networking (Finished), Concurrency (Processes and Threads) September 14th, 2015 Prof. John Kubiatowicz http://cs162.eecs.Berkeley.edu Recall: Namespaces for communication over IP Hostname www.eecs.berkeley.edu IP address 128.32.244.172 (ipv4 format) Port Number 0-1023 are well known or system ports Superuser privileges to bind to one 1024 49151 are registered ports ( registry) Assigned by IANA for specific services 4915265535 (215+214 to 2161) are dynamic or private

Automatically allocated as ephemeral Ports 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.2 Recall: Use of Sockets in TCP Socket: an abstraction of a network I/O queue Embodies one side of a communication channel Same interface regardless of location of other end Could be local machine (called UNIX socket) or remote machine (called network socket) First introduced in 4.2 BSD UNIX: big innovation at time Now most operating systems provide some notion of socket Using Sockets for Client-Server (C/C++ interface): On server: set up server-socket Create socket, Bind to protocol (TCP), local address, port Call listen(): tells server socket to accept incoming requests

Perform multiple accept() calls on socket to accept incoming connection request Each successful accept() returns a new socket for a new connection; can pass this off to handler thread On client: 9/14/15 Create socket, Kubiatowicz UCB Fall 2015 BindCS162 to protocol (TCP), remote Lec 5.3 Recall: Socket Setup over TCP/IP Server Socket new socket socket connection Client socket Server

Server Socket: Listens for new connections Produces new sockets for each unique connection Things to remember: Connection involves 5 values: [ Client Addr, Client Port, Server Addr, Server Port, Protocol ] Often, Client Port randomly assigned Done by OS during client socket setup Server Port often well known 9/14/15 80 (web), 443 (secure web), 25 (sendmail), etc Well-known Kubiatowicz CS162 UCB Fall 2015 ports from 01023 Lec 5.4 Example: Server Protection and Parallelism Server Client Create Server Socket Bind it to an Address

(host:port) Create Client Socket Connect it to server (host:port) Listen for Connection Accept connection child Connection SocketParent Close Listen read request Socket write response write request read response Close Client Socket Close Connection Socket Close Connection Socket Close Server Socket 9/14/15

Kubiatowicz CS162 UCB Fall 2015 Lec 5.5 Recall: Server Protocol (v3) while (1) { listen(lstnsockfd, MAXQUEUE); consockfd = accept(lstnsockfd, (struct sockaddr *) &cli_addr, &clilen); cpid = fork(); /* new process for connection */ if (cpid > 0) { /* parent process */ close(consockfd); } else if (cpid == 0) { /* child process */ close(lstnsockfd); /* let go of listen socket */ server(consockfd); close(consockfd); exit(EXIT_SUCCESS); /* exit child normally */ } } close(lstnsockfd); 9/14/15

Kubiatowicz CS162 UCB Fall 2015 Lec 5.6 Server Address - itself memset((char *) &serv_addr,0, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(portno); Simple form Internet Protocol accepting any connections on the specified port In network byte ordering 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.7 Client: getting the server address struct hostent *buildServerAddr(struct sockaddr_in *serv_addr, char *hostname, int portno) { struct hostent *server;

/* Get host entry associated with a hostname or IP address */ server = gethostbyname(hostname); if (server == NULL) { fprintf(stderr,"ERROR, no such host\n"); exit(1); } /* Construct an address for remote server */ memset((char *) serv_addr, 0, sizeof(struct sockaddr_in)); serv_addr->sin_family = AF_INET; bcopy((char *)server->h_addr, (char *)&(serv_addr->sin_addr.s_addr), server->h_length); serv_addr->sin_port = htons(portno); return server; } 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.8 BIG OS Concepts so far Processes Address Space

Protection Dual Mode Interrupt handlers (including syscall and trap) File System Integrates processes, users, cwd, protection Key Layers: OS Lib, Syscall, Subsystem, Driver User handler on OS descriptors Process control fork, wait, signal, exec Communication through sockets Client-Server Protocol 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.9 Sys te m s OS Concepts Course Structure: Spiral r ib ut ed

Re l i ab ty, enicliy Fi l e Concurr Di st intr o Sy ste m s A d d r e s

s Sp a c e S e cu ri t y , Cl o u d 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.10 Recall: Traditional UNIX Process Process: Operating system abstraction to represent what is needed to run a single program Often called a HeavyWeight Process

No concurrency in a HeavyWeight Process Two parts: Sequential program execution stream Code executed as a sequential stream of execution (i.e., thread) Includes State of CPU registers Protected resources: Main memory state (contents of Address Space) I/O state (i.e. file descriptors) 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.11 How do we Multiplex Processes? The current state of process held in a process control block (PCB): This is a snapshot of the execution and protection environment Only one PCB active at a time Give out CPU time to different processes (Scheduling): Only one process running at a time Give more time to important processes

Give pieces of resources to different processes (Protection): Controlled access to non-CPU resources Example mechanisms: Memory Mapping: Give each process their own address space Kernel/User duality: Arbitrary multiplexing of I/O through system calls 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Process Control Block Lec 5.12 CPU Switch From Process to Process This is also called a context switch Code executed in kernel above is overhead 9/14/15 Overhead sets minimum practical switching time Less overhead with SMT/hyperthreading, but contention for resources instead Kubiatowicz CS162 UCB Fall 2015

Lec 5.13 Lifecycle of a Process As a process executes, it changes state: new: The process is being created ready: The process is waiting to run running: Instructions are being executed waiting: Process waiting for some event to occur terminated: The process has finished execution 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.14 Process Scheduling PCBs move from queue to queue as they change state Decisions about which order to remove from queues are Scheduling decisions Many algorithms possible (few weeks from now) 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.15

Ready Queue And Various I/O Device Queues Thread not running TCB is in some scheduler queue Separate queue for each device/signal/condition Each queue can have a different scheduler policy Ready Queue Head Tail USB Unit 0 Head Tail Disk Unit 0 Head Disk Unit 2 Head Tail Link Registers

Other State TCB6 Link Registers Other State TCB2 Tail Ether Head Netwk 0 Tail 9/14/15 Link Registers Other State TCB9 Link Registers Other State TCB16

Link Registers Other State TCB3 Link Registers Other State TCB8 Kubiatowicz CS162 UCB Fall 2015 Lec 5.16 Administrivia Group signups: 4 members/group Sign up with the autograder Groups need to be finished by this Wednesday! Section Signup form/group Form asks for 3 section options (ranked) for your group Please sign up by Wednesday! We will try to accommodate your needs, but may not be able to fill over-popular sections. Give us options! Need to get to know your Tas Consider moving out of really big sections!

Finding info on your own is a good idea! Learn your tools, like man Can even type man xxx into google! 9/14/15 Example:Kubiatowicz man lsCS162 UCB Fall 2015 Lec 5.17 Modern Process with Threads Thread: a sequential execution stream within process (Sometimes called a Lightweight process) Process still contains a single Address Space No protection between threads Multithreading: a single program made up of a number of different concurrent activities Sometimes called multitasking, as in Ada Why separate the concept of a thread from that of a process? Discuss the thread part of a process (concurrency) Separate from the address space (protection) Heavyweight Process Process with one thread 9/14/15 Kubiatowicz CS162 UCB Fall 2015

Lec 5.18 Single and Multithreaded Processes Threads encapsulate concurrency: Active component Address spaces encapsulate protection: Passive part Keeps buggy program from trashing the system Why have multiple threads per address space? 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.19 Thread State State shared by all threads in process/addr space Content of memory (global variables, heap) I/O state (file descriptors, network connections, etc) State private to each thread Kept in TCB Thread Control Block CPU registers (including, program counter) Execution stack what is this? Execution Stack Parameters, temporary variables Return PCs are kept while called procedures are executing

9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.20 Execution Stack Example A: tmp=1 ret=exit A(int tmp) { if (tmp<2) B: ret=A+2 B(); printf(tmp); C: ret=b+1 } B() { C(); } C() { Stack Pointer A: tmp=2

ret=C+1 Stack Growth A(2); } A(1); 9/14/15 Stack holds temporary results Permits recursive execution Crucial to modern languages Kubiatowicz CS162 UCB Fall 2015 Lec 5.21 0 MIPS: Software conventions for Registers zero constant 0 16 s0 callee saves 1 at reserved for assembler

. . . (callee must save) 2 v0 expression evaluation & 23 s7 3 v1 function results 24 t8 4 a0 arguments 25

t9 5 a1 26 k0 6 a2 27 k1 7 a3 28 gp Pointer to global area 8 t0

temporary: caller saves 29 sp Stack pointer (callee can clobber) 30 fp frame pointer 31 ra Return Address (HW) ... 15 t7 Before calling procedure: 9/14/15

Save caller-saves regs Save v0, v1 Save ra temporary (contd) reserved for OS kernel After return, assume Callee-saves reg OK gp,sp,fp OK (restored!) Other Kubiatowicz CS162 UCB Fall 2015things trashed Lec 5.22 Motivational Example for Threads Imagine the following C program: main() { ComputePI(pi.txt); PrintClassList(clist.text); } What is the behavior here? Program would never print out class list Why? ComputePI would never finish

9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.23 Use of Threads Version of program with Threads (loose syntax): main() { ThreadFork(ComputePI(pi.txt)); ThreadFork(PrintClassList(clist.text)); } What does ThreadFork() do? Start independent thread running given procedure What is the behavior here? Now, you would actually see the class list This should behave as if there are two separate CPU1 CPU2 CPU1 CPU2 CPU1 CPU2 CPUs Time 9/14/15 Kubiatowicz CS162 UCB Fall 2015

Lec 5.24 Memory Footprint: Two-Threads If we stopped this program and examined it with a debugger, we would see Two sets of CPU registers Two sets of Stacks Stack 2 How do we position stacks relative to each other? What maximum size should we choose for the stacks? Heap What happens if threads violate this? Global Data How might you catch violations? Address Space Questions: Stack 1 Code 9/14/15 Kubiatowicz CS162 UCB Fall 2015

Lec 5.25 Actual Thread Operations thread_fork(func, args) Create a new thread to run func(args) Pintos: thread_create thread_yield() Relinquish processor voluntarily Pintos: thread_yield thread_join(thread) In parent, wait for forked thread to exit, then return thread_exit Quit thread and clean up, wake up joiner if any Pintos: thread_exit pThreads: POSIX standard for thread programming 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.26 Dispatch Loop Conceptually, the dispatching loop of the operating system looks as follows:

Loop { RunThread(); ChooseNextThread(); SaveStateOfCPU(curTCB); LoadStateOfCPU(newTCB); } This is an infinite loop One could argue that this is all that the OS does Should we ever exit this loop??? When would that be? 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.27 Running a thread Consider first portion: RunThread() How do I run a thread? Load its state (registers, PC, stack pointer) into CPU Load environment (virtual memory space, etc) Jump to the PC How does the dispatcher get control back?

Internal events: thread returns control voluntarily External events: thread gets preempted 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.28 Internal Events Blocking on I/O The act of requesting I/O implicitly yields the CPU Waiting on a signal from other thread Thread asks to wait and thus yields the CPU Thread executes a yield() Thread volunteers to give up CPU computePI() { while(TRUE) { ComputeNextDigit(); yield(); } } 9/14/15 Kubiatowicz CS162 UCB Fall 2015

Lec 5.29 Stack for Yielding Thread yield Trap to OS kernel_yield run_new_thread switch Stack growth ComputePI How do we run a new thread? run_new_thread() { newThread = PickNewThread(); switch(curThread, newThread); ThreadHouseKeeping(); /* Do any cleanup */ } How does dispatcher switch to a new thread? 9/14/15 Save anything next thread may trash: PC, regs, stack Maintain isolation for each

thread Kubiatowicz CS162 UCB Fall 2015 Lec 5.30 What do the stacks look like? proc A() { B(); } proc B() { while(TRUE) { yield(); } } Stack growth Consider the following code blocks: Thread S Thread T A A

B(while) B(while) yield yield run_new_thread run_new_thread switch switch Suppose we have 2 threads: Threads S and T 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.31 Saving/Restoring state (often called Context Switch)

Switch(tCur,tNew) { /* Unload old thread */ TCB[tCur].regs.r7 = CPU.r7; TCB[tCur].regs.r0 = CPU.r0; TCB[tCur].regs.sp = CPU.sp; TCB[tCur].regs.retpc = CPU.retpc; /*return addr*/ /* Load and execute new thread */ CPU.r7 = TCB[tNew].regs.r7; CPU.r0 = TCB[tNew].regs.r0; CPU.sp = TCB[tNew].regs.sp; CPU.retpc = TCB[tNew].regs.retpc; return; /* Return to CPU.retpc */ } 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.32 Switch Details (continued) What if you make a mistake in implementing switch? Suppose you forget to save/restore register 4 Get intermittent failures depending on when context switch occurred and whether new thread uses register 4 System will give wrong result without warning

Can you devise an exhaustive test to test switch code? No! Too many combinations and inter-leavings Cautionary tail: For speed, Topaz kernel saved one instruction in switch() Carefully documented! Only works As long as kernel size < 1MB What happened? 9/14/15 Time passed, People forgot Later, they added features to kernel (no one removes features!) Kubiatowicz CS162 UCB Fall 2015 Lec 5.33 Some Numbers Frequency of performing context switches: 10-100ms Context switch time in Linux: 3-4 secs (Current Intel i7 & E5). Thread switching faster than process switching (100 ns). But switching across cores about 2x more expensive than within-core switching.

Context switch time increases sharply with the size of the working set*, and can increase 100x or more. * The working set is the subset of memory used by the process in a time window. Moral: Context switching depends mostly on cache limits and the process or threads hunger for memory. 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.34 What happens when thread blocks on I/ O? read Trap to OS kernel_read run_new_thread switch Stack growth CopyFile What happens when a thread requests a

block of data from the file system? User code invokes a system call Read operation is initiated Run new thread/switch Thread communication similar Wait for Signal/Join Networking 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.35 External Events What happens if thread never does any I/O, never waits, and never yields control? Could the ComputePI program grab all resources and never release the processor? What if it didnt print to console? Must find way that dispatcher can regain control! Answer: Utilize External Events Interrupts: signals from hardware or software that stop the running code and jump to kernel Timer: like an alarm clock that goes off every some many milliseconds

If we make sure that external events occur frequently enough, can ensure dispatcher runs 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.36 Thread Abstraction Infinite number of processors Threads execute with variable speed Programs must be designed to work with any schedule 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.37 Programmer vs. Processor View 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.38

Possible Executions 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.39 Thread Lifecycle 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.40 Per Thread Descriptor (Kernel Supported Threads) Each Thread has a Thread Control Block (TCB) Execution State: CPU registers, program counter (PC), pointer to stack (SP) Scheduling info: state, priority, CPU time Various Pointers (for implementing scheduling queues) Pointer to enclosing process (PCB) user threads Etc (add stuff as you find a need) OS Keeps track of TCBs in kernel memory In Array, or Linked List, or I/O state (file descriptors, network connections,

etc) 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.41 Multithreaded Processes PCB points to multiple TCBs: Switching threads within a block is a simple thread switch Switching threads across blocks requires changes to memory and I/O address tables. 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.42 Shared vs. Per-Thread State 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.43

Examples multithreaded programs Embedded systems Elevators, Planes, Medical systems, Wristwatches Single Program, concurrent operations Most modern OS kernels Internally concurrent because have to deal with concurrent requests by multiple users But no protection needed within kernel Database Servers Access to shared data by many concurrent users Also background utility processing must be done 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.44 Example multithreaded programs (cont) Network Servers Concurrent requests from network Again, single program, multiple concurrent operations File server, Web server, and airline reservation systems

Parallel Programming (More than one physical CPU) Split program into multiple threads for parallelism This is called Multiprocessing Some multiprocessors are actually uniprogrammed: Multiple threads in one address space but one program at a time 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.45 A typical use case Client Browser - process for each tab - thread to render page - GET in separate thread - multiple outstanding GETs - as they complete, render portion 9/14/15 Web Server - fork process for each client

connection - thread to get request and issue response - fork threads to read data, access DB, etc - join and respond Kubiatowicz CS162 UCB Fall 2015 Lec 5.46 Some Actual Numbers Many process are multi-threaded, so thread context switches may be either within-process or across-processes. 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.47 Kernel Use Cases Thread for each user process Thread for sequence of steps in processing I/O Threads for device drivers

9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.48 Putting it together: Process (Unix) Process Sequential stream of instructions 9/14/15 A(int tmp) { if (tmp<2) B(); printf(tmp); } B() { C(); } C() { A(2); } A(1); Memory

Stack Resources I/O State (e.g., file, socket contexts) CPU state (PC, SP, registers..) Kubiatowicz CS162 UCB Fall 2015 Stored in OS Lec 5.49 Putting it together: Processes Process 1 Process 2 Mem . Mem . IO

state IO state CPU state CPU state Process N Switch overhead: high Mem . CPU sched. CPU (1 core) 9/14/15 IO state CPU state

OS CPU state: low Memory/IO state: high Process creation: high Protection CPU: yes Memory/IO: yes Sharing overhead: high (involves at least a context switch) 1 process at a time Kubiatowicz CS162 UCB Fall 2015 Lec 5.50 Putting it together: Threads Process 1 Process N threads Mem .

IO state CPU state threads CPU state CPU state CPU sched. CPU (1 core) 9/14/15 Mem . IO state

CPU state OS 1 thread at a time Switch overhead: low (only CPU state) Thread creation: low Protection CPU: yes Memory/IO: No Sharing overhead: low (thread switch overhead low) Kubiatowicz CS162 UCB Fall 2015 Lec 5.51 Kernel versus User-Mode threads We have been talking about Kernel threads Native threads supported directly by the kernel Every thread can run or block independently One process may have several threads waiting on different things

Downside of kernel threads: a bit expensive Need to make a crossing into kernel mode to schedule Even lighter weight option: User Threads User program provides scheduler and thread package May have several user threads per kernel thread User threads may be scheduled non-premptively relative to each other (only switch on yield()) Cheap Downside of user threads: When one thread blocks on I/O, all threads block Kernel cannot adjust scheduling among all threads Option: Scheduler Activations Have kernel inform user level when thread blocks 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.52 Some Threading Models Simple One-to-One Threading Model Many-to-One 9/14/15 Many-to-Many Kubiatowicz CS162 UCB Fall 2015

Lec 5.53 Threads in a Process Threads are useful at user-level Parallelism, hide I/O latency, interactivity Option A (early Java): user-level library, within a singlethreaded process Library does thread context switch Kernel time slices between processes, e.g., on system call I/O Option B (SunOS, Unix variants): green Threads User-level library does thread multiplexing Option C (Windows): scheduler activations Kernel allocates processors to user-level library Thread library implements context switch System call I/O that blocks triggers upcall Option D (Linux, MacOS, Windows): use kernel threads System calls for thread fork, join, exit (and lock, unlock,) Kernel does context switching Simple, but a lot of transitions between user and kernel mode 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.54

Putting it together: Multi-Cores Process 1 Process N threads Mem . IO state CPU state threads CPU state CPU state CPU sched.

core 1 9/14/15 Core 2 Mem . IO state Core 3 CPU state Switch overhead: low (only CPU state) Thread creation: low Protection CPU: yes Memory/IO: No OS Sharing overhead: low (thread switch

4 threads at overhead low, may a time not need to switch Core 4 CPU at all!) Kubiatowicz CS162 UCB Fall 2015 Lec 5.55 Putting it together: Hyper-Threading Process 1 Process N threads Mem . IO state CPU state threads

CPU state hardware-threads (hyperthreading) Mem . IO state CPU state CPU sched. CPU state OS 8 threads at a time Switch overhead between hardwarethreads: verylow (done in hardware) Contention for

ALUs/FPUs may hurt performance CPU core 1 9/14/15 core 2 core 3 core 4 Kubiatowicz CS162 UCB Fall 2015 Lec 5.56 # threads Per AS: One Many # of addr spaces: Classification

One MS/DOS, early Macintosh Embedded systems (Geoworks, VxWorks, JavaOS,etc) JavaOS, Pilot(PC) Many Traditional UNIX Mach, OS/2, Linux Windows 9x??? Win NT to XP, Solaris, HP-UX, OS X Real operating systems have either One or many address spaces One or many threads per address space Did Windows 95/98/ME have real memory protection? No: Users could overwrite process tables/System 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.57

DLLs Summary Processes have two parts Threads (Concurrency) Address Spaces (Protection) Concurrency accomplished by multiplexing CPU Time: Unloading current thread (PC, registers) Loading new thread (PC, registers) Such context switching may be voluntary (yield(), I/ O operations) or involuntary (timer, other interrupts) Protection accomplished restricting access: Memory mapping isolates processes from each other Dual-mode for isolating I/O, other resources Various Textbooks talk about processes When this concerns concurrency, really talking about thread portion of a process When this concerns protection, talking about address space portion of a process 9/14/15 Kubiatowicz CS162 UCB Fall 2015 Lec 5.58

Recently Viewed Presentations

  • Good Morning Please sit at your assigned table,

    Good Morning Please sit at your assigned table,

    This is also known as propositional knowledge, and is the type of knowledge that we are concerned with in TOK. Knowing how is skill-based knowledge, or things we know how to do, like play a sport, program a computer, paint...
  • FHSAA Basketball

    FHSAA Basketball

    Rules Update. Backcourt Violations. An EXCEPTION added to the backcourt violation (9-9-1): To ensure that an offensive team is not unfairly penalized when the ball is deflected by the defense from the frontcourt to the backcourt. This exception allows the...
  • The Community Rule - Mass.Gov

    The Community Rule - Mass.Gov

    As part of this indicator, will be looking at ensuring that all individuals have a "lockable bedroom door" (unless it leads to an egress or unless documented in the ISP as contra-indicated) L54 Strengthened privacy in bathroom and personal conversations....
  • AEGIS Secure Processor G. Edward Suh, Dwaine Clarke,

    AEGIS Secure Processor G. Edward Suh, Dwaine Clarke,

    Summary Physical attacks are becoming more prevalent DRM, software licensing, distributed computing, etc. Single-chip secure processors provide trusted execution environments with acceptable overhead Tamper-Evident environment, Private Tamper-Resistant environment Simulation results show 5-15% overhead for TE, 10-25% overhead for PTR processing...
  • Carbohydrates The Preferred Body Fuel Carbohydrates 1 of

    Carbohydrates The Preferred Body Fuel Carbohydrates 1 of

    Single sugar unit (aka "simple sugars") Smallest carbohydrate unit. Glucose - blood sugar - body's source of energy. Fructose - found in fruit. Galactose - found in milk bonded to glucose. Monosaccharides - Simple Carb. 2 sugar units bonded together.
  • Specialization and Interdependence in the Colonies

    Specialization and Interdependence in the Colonies

    Specialization & Interdependence . New England Colonies. The New England colonies depended on the Mid-Atlantic Colonies for livestock and grains. The New England colonies depended on the Southern colonies for crops like tobacco, rice, cotton, and indigo, as well as...
  • Markowitz Risk - Return Optimization

    Markowitz Risk - Return Optimization

    Two mutual fund theorem. One key result of the above analysis is the two mutual fund theorem. This theorem states that any portfolio on the efficient frontier can be generated by holding a combination of any two given portfolios on...
  • KS2 SATs 2017

    KS2 SATs 2017

    Reading preparation: Read outside the bookChildren need to get used to reading non-fiction texts as well as stories. Try to encourage children to read texts associated with events or interests that are meaningful to them; for example, if they like...