0% found this document useful (0 votes)
78 views4 pages

Integers Floating Point: N N S E

The document summarizes key differences between integer and floating point number representations. It also provides details on: 1) Integer and floating point number formats including sign, exponent, and significand fields. Floating point lacks associativity. 2) Normalized and denormalized floating point values. Normalized values have a normalized exponent and significand. 3) Special floating point values like infinity and NaN. 3) Floating point operations like multiplication which involves exponent addition and significand multiplication with normalization.

Uploaded by

Fitrah Ramdhani
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
78 views4 pages

Integers Floating Point: N N S E

The document summarizes key differences between integer and floating point number representations. It also provides details on: 1) Integer and floating point number formats including sign, exponent, and significand fields. Floating point lacks associativity. 2) Normalized and denormalized floating point values. Normalized values have a normalized exponent and significand. 3) Special floating point values like infinity and NaN. 3) Floating point operations like multiplication which involves exponent addition and significand multiplication with normalization.

Uploaded by

Fitrah Ramdhani
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Integers Floating Point

n 2 n
Hex Binary n 2n • Floating point lacks associativity
0 1 0x00 00000 17 131072 • V = (−1)s × M × 2E
1 2 0x01 00001 18 262144 • Sign bit s – whether the number is positive or negative,
represented by 1-bit field
2 4 0x02 00010 19 524288
• Exponent E weights the value by a possibly negative
3 8 0x03 00011 20 1048576
power of 2, represented by k-bit exp field
4 16 0x04 00100 21 2097152
• Significand (mantissa) M – fractional binary number be-
5 32 0x05 00101 22 4194304
tween 1 and 2 − ε or between 0 and 1 − ε, represented by
6 64 0x06 00110 23 8388608
n-bit frac field (fn−1 · · · f1 f0 )
7 128 0x07 00111 24 16777216 • Normalized values
8 256 0x08 01000 25 33554432
9 512 0x09 01001 26 67108864 – Most common case
10 1024 0x0A 01010 27 134217728 – exp is neither all zeros nor all ones
11 2048 0x0B 01011 28 268435456 – Exponent field represents biased signed integer
– E = e−Bias where e is the unsigned number in exp
12 4096 0x0C 01100 29 536870912
and Bias = 2k−1 − 1
13 8192 0x0D 01101 30 1073741824
– frac represents 0 ≤ f < 1 with 0.fn−1 · · · f1 f0 and
14 16384 0x0E 01110 31 2147483648
M = 1 + f – implied leading 1
15 32768 0x0F 01111 32 4294967296
16 65536 0x10 10000 33 8589934592 • Denormalized values
– Exponent field all zeros
• Word size – nominal size of pointer data – Exponent value is E = 1−Bias, significand value is
• Addresses go up to 2w − 1 for w-bit word size M = f (no leading 1)
• Little Endian – least significant byte comes first – Numbers close to zero (inclusive), evenly spaced near
• Big Endian – most significant byte comes first 0.0
• Example of storing 0x1234567 at 0x100
0x100 0x101 0x102 0x103 • Special values
Big endian 01 23 45 67 – Exponent field is all ones
Little endian 67 45 23 01 – Fraction field all zeros can represent ±∞, depending
on sign bit
• Arithmetic between signed and unsigned values automat-
– Nonzero fraction field is NaN
ically casts all signed values to unsigned
• −T M inw = T M inw • Rounding
• dx/2k e is given by (x + (1 << k) - 1) >> k – Rounds to the nearest even
• x/2k is given by (x<0 ? x+(1<<k)-1 : x) >> k – BBGRXXXX
– G – Guard bit; least significant bit of result
Word size w – R – Round bit; first bit removed
Value 8 16 32 – XXXX – Sticky bit; OR of remaining bits
U M axw 0xFF 0xFFFF 0xFFFFFFFF – Round up conditions:
255 65,535 4,294,967,295
∗ Round = 1, Sticky = 1 → > 0.5
T M inw 0x80 0x8000 0x80000000 ∗ Guard = 1, Round = 1, Sticky = 0 → Round
−128 −32, 768 −2, 147, 483, 648 to even
T M axw 0x7F 0x7FFF 0x7FFFFFFF
127 32, 767 2, 147, 483, 647 • Multiplication
−1 0xFF 0xFFFF 0xFFFFFFFF – (−1)s1 M1 2E1 × (−1)s2 M2 2E2
= (−1)s1 ˆs2 (M1 × M2 )2E1 +E2
– If M1 × M2 = M ≥ 2 shift M right, increment
Bitwise Operations E = E1 + E2
• Logical shift – Fills left end with zeros – If E out of range, overflow
• Arithmetic shift – Sign-extends left end – Round M to fit frac precision

~ & 0 1 | 0 1 ^ 0 1
0 1 0 0 0 0 0 1 0 0 1
1 0 1 0 1 1 1 1 1 1 0
x86-64 Data Alignment Assembly Basics
• Internal padding – added between struct elements • “word” refers to 16-bit data type, with “double word”
• External padding – added after struct elements referring to 32-bit (int) and 64-bit quantities referred to
• The entire struct is externally padded to align to its as “quad words”
largest element • On 64-bit machines pointers are 8-byte quad words
• 16 general purpose registers storing 64-bit values (register
K Types file)
1 char • In operands, scaling factor s must be either 1, 2, 4, or 8
2 short • mov S, D has the effect of S → D
4 int, float • movzbq moves from byte to quad with zero-extended
8 long, double, char * whereas movsbq does the same but sign-extended
• Stack grows down if increasing addresses grow up – “top”
of the stack at the bottom
• leaq S, D has the effect of &S → D
Caches
• M = 2m unique addresses of m bits Type Form Operand value
• S = 2s cache sets Immediate $Imm Imm
• Each set consists of E cache lines
Register ra R[ra ]
• Each line consists of a data block of B = 2b bytes, a valid
Memory Imm(rb , ri , s) M[Imm + R[rb ] + R[ri ] · s]
bit and t = m − (b + s) tag bits
• Capacity of a cache is C = S × E × B
• Address Type 64-bits 32-bits 16-bits 8-bits
Return val %rax %eax %ax %al
t bits s bits b bits Callee %rbx %ebx %bx %bl
←m−1 0→ 1st arg %rdi %edi %di %dil
Tag Set index Block offset 2nd arg %rsi %esi %si %sil
• Direct-mapped cache has one line per set (E = 1) 3rd arg %rdx %edx %dx %dl
• Non-direct caches sometimes referred to as E-way set 4th arg %rcx %ecx %cx %cl
associative cache 5th arg %r8 %r8d %r8w %r8b
• Fully-associative cache has one set (E = C/B). 6th arg %r9 %r9d %r9w %r9b
Callee %rbp %ebp %bp %bpl
Stack ptr %rsp %esp %sp %spl
Conditional Control Caller %r10 %r10d %r10w %r10b
• Carry flag (CF) – most recent op generated carry of most Caller %r11 %r11d %r11w %r11b
significant bit, detects overflow for unsigned Callee %r12 %r12d %r12w %r12b
• Zero flag (ZF) – most recent op yielded zero Callee %r13 %r13d %r13w %r13b
• Sign flag (SF) – most recent op yielded negative value Callee %r14 %r14d %r14w %r14b
• Overflow flag (OF) – most recent op caused two’s comple- Callee %r15 %r15d %r15w %r15b
ment overflow
• test instruction behaves like and instructions but sets
condition codes without altering source or destination Linking
often see testq %rax,%rax to check if return val is neg,
zero, or pos • Relocatable object files – combine with other relocatables
at compile time to create executables, made by compiler
set D and jmp suffixes and assembler
Instruction Syn. Cond. Desc. • Executable object files – contain binary data that can be
-e -z ZF = /0 directly copied to memory and executed, made by linker
-ne -nz ~ZF ! =/not zero • Shared object files – special relocatable objects that can
-s SF Neg be linked dynamically at load or run time
-ns ~SF Nonneg • Static symbols – defined locally to an object file (module)
-g -nle ~(SF^OF)&~ZF signed > • Global symbols – defined locally and referred to elsewhere
• Externals – Global symbols referenced locally but defined
-ge -nl ~(SF^OF) signed =>
elsewhere
-l -nge SF^OF signed <
• Local linker symbols are different from local program
-le -ng (SF^OF)|ZF signed <=
variables
-a -nbe ~CF&~ZF unsigned >
• Functions and initialized global variables are exported to
-ae -nb ~CF unsigned >=
the assembler as strong by the compiler
-b -nae CF unsigned < • Uninitialized global variables are weak
-be -na CF|ZF unsigned <= • Linkers error on multiple same-name strong symbols, pick
strong over weak, and randomly choose from weak symbols
Processes Signals
• getpid(void) – pid t of the process • Default action of SIGCHLD, SIGCONT, SIGSTOP,
• getppid(void) – pid t of the parent process SIGTSTP is to ignore and stop (respectively per pair)
• Processes are running, stopped, or terminated • Signals can be sent to process groups; child inherits parent
• exit(int status) – called once, never returns process group by default; setpgid(0, 0) sets the process
• fork(void) – pid t of child in parent or 0 if in child; group ID to the current process id
called once, returns twice • kill(pid t pid, int sig) – send a sig to pid, unless
• Open file table and vnode table are managed by OS and pid is 0 then send it to every process in the process group
shared across processes, file descriptor table is process- of the calling process; if pid < 0, send to every process
specific in process group |pid|
• waitpid(pid t pid, int *statusp, int options) – • signal(int sig, void *hndlr t (int) handler) –
returns pid t of child, 0 if not waiting (WNOHANG) or error handle sig with handler function pointer; handler can
– WNOHANG – return (0) immediately and don’t wait be SIG IGN to ignore or SIG DFL for default
for child • sigprocmask(int how, sigset t *set, sigset t
– WUNTRACED – check for terminated and stop children *oldset)
– WCONTINUED – check for waiting (child) process to – SIG BLOCK – blocked = blocked | set
be continued – SIG UNBLOCK – blocked = blocked & set
– OR (|) flags together to form a bit vector – SIG SETMASK – blocked = set
– WIFEXITED(status) – whether child exited normally – Old bit vector stored in oldset (a.k.a. prev)
– WEXITSTATUS(status) – returns exit status of ter- • sigemptyset(sigset t *set)
minated child if WIFEXITED is true • sigfillset(sigset t *set)
– WIFSIGNALED & WTERMSIG – as above but for signals • sigaddset(sigset t *set, int sig) – add sig
– WIFSTOPPED & WSTOPSIG & WIFCONTINUED – as • sigdelset(sigset t *set, int sig) – delete sig
above for stopped/continued processes • Rules for signal handlers
• wait(int *statusp) = ∼ waitpid(-1, &status, 0)
1. Keep them simple
• sleep(unsigned int secs) – returns short counts
• pause(void) – sleeps until a signal is received 2. Only call async-signal-safe functions (reentrant or
• execve(char *filename, char *argv[], char uninterruptible)
*envp[]) – does not return unless error; last arg 3. Save and restore errno
in each array is NULL 4. Block all signals
5. Declare global variables with volatile – force mem-
Virtual Memory ory read each time (no storage in registers)
• N = 2n addresses in n-bit virtual address space 6. Declare flags with sig atomic t – atomic r/w
• M = 2m addresses in m-bit physical address space (not • Signals are not queued
necessarily power of 2) • sigsuspend(sigset t *mask) – atomically replace
• P = 2p bytes per virtual/physical page blocked with mask and suspend until handler returns
• Virtual pages are either unallocated, cached (allocated in after receipt of a signal, then restore blocked
PM), or uncached (allocated, not in PM)
• DRAM caches are often fully associative
• Page table maps virtual pages to physical pages Concurrency with Threads
• Valid bit in PTE set indicates cached in PM, rest indicates • pthread create(pthread t *tid, NULL, void
virtual or physical address (depending on valid bit) *func(void *), void *arg) – run func with arg
• Page fault is DRAM cache miss; triggers exception in a new thread, joinable by default
• Translation lookaside buffer (TLB) is a cache of PTEs; • pthread self(void) – return current thread id
each line holds a block with one PTE; highly associative • pthread exit(void *return) – exit the current thread
• TLB has T = 2t sets • pthread cancel(pthread t tid) – terminate another
• Virtual address thread without waiting
• pthread join(pthread t tid, NULL) – block and wait
Virtual Page Number
for the thread with tid to terminate
←n−1 ←p+t | p→ 0→
• pthread detach(pthread t tid) – make thread tid de-
TLB Tag TLB index Virtual page offset
tached (not joinable), often called on self
• Threads share everything in memory except for registers
Dynamic Memory Allocation and stack, though they can access addresses in other
thread stacks
• sbrk(intptr t incr) – extend the heap by incr (basi-
cally just an int) and return the old break pointer
System I/O Scratch work:
• open(char *filename, int flags, mode t mode) –
returns file descriptor
– O RDONLY, O WRDONLY, O RDWR flags
– O CREAT – create a new file if it doesn’t exist
– O TRUNC – truncate the file if it exists
– O APPEND – before write, set file pos. to end of file
– Mode given by OR (|) combination of
S I{R, W, X}{USR, GRP, OTH}
– Each call creates new open file table entry
• read(int fd, void *buf, size t n) – read up to n
bytes into buf and return the number of bytes actually
read, update file descriptor table position by return value
• write(int fd, void *buf, size t n) – write up to n
bytes from buf, return the number of bytes actually writ-
ten, update file descriptor table position by return value
• Each process has unique descriptor table pointing to en-
tries in global file table
• OS maintains open file table shared by all processes, each
entry has file position, ref count, and pointer to v-node
table
• OS maintains v-node table with information about each
file
• Parent and child process must both close file descriptors
for kernel to remove file table entry
• dup2(int oldfd, int newfd) – copies descriptor entry
oldfd to newfd, overwriting newfd (closes newfd if open);
i.e., newfd entry points to oldfd entry

Thread Synchronization
• sem init(sem t *sem, 0, int val) – initialize lock
• sem wait(sem t *sem) – P(sem); block until get lock
• sem post(sem t *sem) – V(sem); release lock
• In producer-consumer solution, producer produces when-
ever there is space in buffer, and consumer consumes
whatever is there as fast as it can
• First readers-writers problem favors readers
• Second readers-writers problem favors writers
• Readers-writers solutions can result in starvation
• Deadlock – threads are waiting for condition that will
never be true

Network Programming
• socket(int domain, int type, int protocol) –
usually AF INET, SOCK STREAM, 0, respectively; create
endpoint of connection
• connect(int clientfd, struct sockadd *addr,
socklen t addrlen) – establish connection with a
server at addr (client)
• bind(int sockfd, struct sockaddr *adrr,
socklen t addrlen) – associate server socket ad-
dress with given socket descriptor (server)
• listen(int sockfd, int backlog) – set sockfd to ac- Created for 15-213 at Carnegie Mellon University
tively listen (server) in Spring 2019 by Jacob Strieb.
• accept(int listenfd, struct sockaddr *addr, [email protected]
int *addrlen) – block until a connection is made then https://git.io/JcZ29
return file descriptor for connection

You might also like