Bits and Bytes סיביות ובתים

Bits and Bytesסיביות ובתים • נושאים • מדוע ביטים ? • ייצוג מידע בינארי / הקסדצימלי • ייצוג של בתים • מספרים • תווים ומחרוזות • פקודות (instructions) • פעולות ברמת הביטים • לוגיקה בוליאנית • כיצד הדבר נראה בתוכניות C ?

מדוע מחשבים לא עובדים בבסיס 10 ? המחשב האלקטרוני הראשון ENIAC השתמש ב 10 שפורפרות ואקום לכל ספרה. • קושי טכני... • קשה לאגור מידע • קשה להעביר מידע • דרוש דיוק גבוה כדי לקודד 10 רמות שונות של אינפורמציה על מוליך אחד. • מסובך לבצע חישובים לוגיים • חיבור, כפל...

0 1 0 3.3V 2.8V 0.5V 0.0V ייצוג בינארי • מימוש בחומרה • קל לאגור עם אלמנטים bi-stable • העברה אמינה גם כשהמוליכים לא אמינים ומדויקים

סיביות

ייצוג בינארי • ייצוג בינארי (בסיס 2) • נייצג את 1521310עם 111011011011012 • בהמשך נלמד איך מייצגים שברים: • נייצג את 1.5213 X 104עם 1.11011011011012 X 213 • נייצג את 1.2010עם 1.0011001100110011[0011]…2 סיביות13

Decimal Binary Hex 0 0000 0 1 0001 1 2 0010 2 3 0011 3 4 0100 4 5 0101 5 6 0110 6 7 0111 7 8 1000 8 9 1001 9 10 1010 A 11 1011 B 12 1100 C 13 1101 D 14 1110 E 15 1111 F ייצוג מספרים בבסיסים שונים • ייצוג hexadecimal: • בסיס 16 • ספרות 0- 9 ואותיות ‘A’–‘F’ • ב – C כתובFA1D37B16 כך: 0xFA1D37Bאו 0xfa1d37b

דוגמה: טווח של ערכי בתים • בית = 8 סיביות • Binary 000000002 to 111111112 • Decimal: 010 to 25510 • Hexadecimal 0016 to FF16

מלים (machine words) • לכל מחשב יש 'רוחב מילה' • הגודל המוקצה למידע מסוג integer (כולל כתובות). • רב המחשבים היום עובדים עם רוחב של 32 סיביות (4 בתים) • מגביל את מרחב הכתובות ל – GB4 • מתחיל להיות צפוף... • מחשבים מתקדמים יותר עובדים עם 64 סיביות (8 בתים) • מרחב הכתובות  1.8 X 1019 בתים

ארגון הזיכרון לפי בתים • תוכניות מתייחסות לכתובות 'מדומות' (וירטואליות) • באופן אבסטרקטי: מערך גדול של בתים • בפועל ממומש עם היררכיה שלמה של סוגי זיכרונות • מהדר (compiler) +רכיבי חומרה קובעים את המיפוי לזיכרון הפיזי. • נראה את ייצוג הכתובות במערך זה.

ארגון הזיכרון לפי מלים 64-bit Words 32-bit Words Bytes Addr. • הכתובות הן של בתים • הבית הראשון במילה • כתובות של מלים עוקבות רחוקות זו מזו ב 4 או 8, לפי רוחב המילה. 0000 Addr = ?? 0001 0002 0000 Addr = ?? 0003 0004 0000 Addr = ?? 0005 0006 0004 0007 0008 Addr = ?? 0009 0010 0008 Addr = ?? 0011 0008 0012 Addr = ?? 0013 0014 0012 0015

ייצוג מידע • גודל בבתים של אובייקטים שונים של C: • C Data Type Compaq Alpha Typical 32-bit Intel IA32 • int 4 4 4 • long int 8 4 4 • char 1 1 1 • short 2 2 2 • float 4 4 4 • double 8 8 8 • long double 8 8 10/12 • char * 8 4 4 • Or any other pointer

סידור המידע • ניתן לסדר את הבתים בתוך מלים מימין לשמאל או להפך... • מה מקובל ? אין הסכמה • Sun’s, Mac’s are “Big Endian” machines • הבית הימני ((least significant byte בכתובת הגבוהה • Alphas, PC’s are “Little Endian” machines • הבית הימני בכתובת הנמוכה

0x100 0x101 0x102 0x103 01 23 45 67 0x100 0x101 0x102 0x103 67 45 23 01 דוגמה • Big Endian • הבית הימני בכתובת הגבוהה • Little Endian • הבית הימני בכתובת הנמוכה • x = 0x01234567 • למשתנה x יש ייצוג ב 4 בתים. • נניח שהכתובת של x (כלומר &x) היא 0x100 Big Endian 01 23 45 67 Little Endian 67 45 23 01

כיצד נראה איך המידע מיוצג • תוכנית להדפסת ייצוג בבתים typedef unsigned char *pointer; void show_bytes(pointer start, int len) { int i; for (i = 0; i < len; i++) printf("0x%p\t0x%.2x\n", start+i, start[i]); printf("\n"); } • Printf directives: • %p: Print pointer • %x: Print Hexadecimal בכמה תעלה כאן הכתובת ?

נפעיל אתshow_bytes מחזיר 4:האורך בבתים של int int a = 15213; printf("int a = 15213;\n"); show_bytes((pointer) &a, sizeof(int)); בית = 8 ביטים, לכן ניתן לייצג אותו עם 2 תוים ב Hex. Result (Linux): int a = 15213; 0x11ffffcb8 0x6d 0x11ffffcb9 0x3b 0x11ffffcba 0x00 0x11ffffcbb 0x00 ארבעת הבתים לייצוג a . שימו לב לכתובות העוקבות.

חידה • שינוי קטן אחד typedef unsigned int *pointer; void show_bytes(pointer start, int len) { int i; for (i = 0; i < len; i++) printf("0x%p\t0x%.2x\n", start+i, start[i]); printf("\n"); } • printf directives: • %p: Print pointer • %x: Print Hexadecimal

נפעיל אתshow_bytes אותה קריאה כמו קודם int a = 15213; printf("int a = 15213;\n"); show_bytes((pointer) &a, sizeof(int)); זאת התשובה מקודם מה יהיה פלט התוכנית ? Result (Linux): int a = 15213; 0x0012FF1C 0x3b6d 0x0012FF20 0x12ff80 0x0012FF24 0x401264 0x0012FF28 0x251fe4 שימו לב להפרש של 4 בין הכתובות זאת אינפורמציה שבמקרה נמצאת בכתובות אלה מה קרה כאן ? הכתובת start + i התקדמה לפי הטיפוס (type): 1 ב char ו 4 ב Int

C A B 6D 93 6D 3B C4 3B 00 00 FF 00 00 FF ייצוג integers Decimal: 15213 Binary: 0011 1011 0110 1101 Hex: 3 B 6 D • int A = 15213; • int B = -15213; • long int C = 15213; ייצוג ב Linux נובע מייצוג הנקרא Two’s complement נראה זאת בהרצאה הבאה. לא כל רוחב המילה מנוצל. (אפסים מובילים)

EF D4 FF F8 FB FF 2C BF ייצוג מצביעים (pointers) • int B = -15213; • int *P = &B; Sun Address Hex: E F F F F B 2 C Binary: 1110 1111 1111 1111 1111 1011 0010 1100 Linux Address Hex: B F F F F 8 D 4 Binary: 1011 1111 1111 1111 1111 1000 1101 0100 מסקנה 1:מהדרים שונים ומחשבים שונים משימים כתובות שונות מסקנה 2: קוד שמסתמך על כתובת (מקובל ב hashing) יפעל שונה במחשבים שונים. יוצר בעיות porting

Linux F 00 IEEE Single Precision Floating Point Representation Hex: 4 6 6 D B 4 0 0 Binary: 0100 0110 0110 1101 1011 0100 0000 0000 15213: 1110 1101 1011 01 B4 6D 46 ייצוג שברים (floats) • בהמשך נלמד איך שברים מיוצגים. עכשיו נראה רק דוגמה. • Float F = 15213.0; IEEE Single Precision Floating Point Representation Hex: 4 6 6 D B 4 0 0 Binary: 0100 0110 0110 1101 1011 0100 0000 0000 15213: 1110 1101 1011 01 IEEE Single Precision Floating Point Representation Hex: 4 6 6 D B 4 0 0 Binary: 0100 0110 0110 1101 1011 0100 0000 0000 15213: 1110 1101 1011 01 לא זהה, אם כי דומה, לייצוג מספרים שלמים.

31 35 32 31 33 00 ייצוג מחרוזות • char S[6] = "15213"; Linux • מחרוזות ב C • מיוצג על ידי מערך של תוים • כל תו מקודד ב ASCII • התו '0' מיוצג כ 0x30 • הספרה i מיוצגת כ 0x30 + i • מחרוזת מסתיימת ב ‘\0’

ייצוג פקודות מכונה • פקודות מקודדות כבתים • מחשבי RISC כגון Sun משתמשים באוסף קטן של פקודות:4 בתים מספיקים לייצוג כל הפקודות. • מחשבי CISC כגון ה - PC משתמשים בקבוצה גדולה של הוראות: נעזרים בגודל משתנה של פקודה.

Sun sum PC sum 55 81 45 90 08 89 C3 0C 89 02 E5 E0 00 EC 03 8B 08 5D 45 09 C3 ייצוג פקודות לכל פקודה יש קוד מספרי. • int sum(int x, int y) • { • return x+y; • } • דוגמה זאת מתורגמת למספר פקודות בסיסיות בשפת מכונה. • בדוגמה זאת מחשבי Alpha, Sun משתמשים ב 4 בתים. • בדוגמה זאת מחשבי PC משתמשים בפקודות באורכים של 1,2,3 בתים. קידוד הפקודה sum מחשבים שונים משתמשים בפקודות שונות וקידוד שונה של הפקודות. אין סיכוי לתאימות!

מה עכשיו ? • עכשיו, כשראינו שאת כל סוגי המידע שהמחשב משתמש בהם... • שלמים, עשרוניים, מחרוזות, פקודות, כתובות,... • ... ניתן לייצוג על ידי 0 ו 1, ... • ... נרצה לראות איך המחשב יכול לבצע חישובים עם מידע זה. • לשם כך, עלינו להיזכר בלוגיקה פסוקית.

And • Or • Not • Exclusive-Or (Xor) לוגיקה פסוקית (/בוליאנית) • פותח על ידי George Bool במאה ה - 19 • נקודד 'אמת' כ – 1 ו 'שקר' כ - 0

חידות • כמה שערים לוגיים (= פונקציות בוליאניות מעל 2 משתנים)שונים ניתן לבנות ? • 16 • כמה פונקציות בוליאניות שונות יש מעל n משתנים ? • 22n • מה המספר המינימלי של שערים לוגיים שונים אשר דרוש כדי לייצג את כל הפונקציות הבוליאניות ?

הכל זה טרנזיסטורים... כיצד באמת המתג נפתח ?"מוליכים למחצה..."

ניתן לחשוב על מימוש השערים באופן הבא: Input 2 Input 1 And gate Input 1 Or gate Input 2

Q = A & B Q = A |B

משערים לפונקציות בוליאניות • ננסה לבנות פונקציה מורכבת יותר מהשערים הבודדים:

נשוה אלגברה בוליאנית לאלגברה אריתמטית • נציב ‘+’ = ‘|’ ו ‘*’ = ‘&’. • תרגיל: עבור כל אחד מהביטויים הבאים – קבעו אם הביטוי המקביל נכון. • קומוטטיביות A | B = B | A A + B = B + A A & B = B & A A * B = B * A • אסוציאטיביות (A + B) + C = A + (B + C) (A * B) * C = A * (B * C)

נשוה אלגברה בוליאנית לאלגברה אריתמטית • ... המשך • A * (B + C) = A * B + A * C • A + 0 = A • A | A = A • A & 1 = A • A * 0 = 0 • A | (B & C) = (A | B) & (A | C) • – (– A) = A • A + A  A

נשוה אלגברה בוליאנית לאלגברה אריתמטית • ... המשך • A & A = A • A | (A & B) = A • A & (A | B) = A • A | ~A = 1 • A | ~A  0

מספר זהויות: & ו - ^ • תרגיל:מצא את הזהויות השגויות • A ^ B = B ^ A • A & B = B & A • (A ^ B) ^ C = A ^ (B ^ C) • (A & B) & C = A & (B & C) • A & (B ^ C) = (A ^ B) & (A ^ C) • A ^ 0 = 0 • A & 1 = A • A & 0 = 0 • A ^ A = A

מימוש לוגיקה פסוקית עם חומרה • כבר ראינו שכל פעולה לוגית ניתנת למימוש בחומרה • שערים לוגיים: • נבנה מעגל לדוגמה: חיבור מספרים

חיבור וקטורים של ביטים • 01001101 + • 10000100 • ------------ • 11010001 • 0010101 + • 1101100 • ------------ • 0000001

כיצד נממש חיבור עם לוגיקה פסוקית ? • נתחיל מחיבור שני ביטים a,b • נוסיף ביט שלישי i (מייצג את השארית מימין אם כחלק מחיבור מספר גדול יותר מביט אחד). • רכיב הנקרא Full Adder (FA) • S – הסכום • ניתן לחישוב על ידי:S $ ((a^b)^ i) • o - השארית • ניתן לחישוב על ידי: o $ ((a & b) | (( a ^ b) & i)) • כלומר, ניתן לבנות מעגל המבוסס על פעולות בוליאניות שמממש חיבור של ביטים

ועתה נחבר מספרים גדולים יותר... • נחבר FA בשרשרת... • נקרא לזה Adder • באופן דומה ניתן לממש פעולות אריתמטיות אחרות • כל מעבד מכיל (ברכיב הנקרא ALU) מימוש דומה לזה של פעולות אריתמטיות

מביטים לוקטורים של ביטים • פעולות על וקטורים של ביטים • פעולות מבוצעות לחוד עבור כל ביט (bitwise) 01101001 & 01010101 01000001 01101001 | 01010101 01111101 01101001 ^ 01010101 00111100 ~ 01010101 10101010 01000001 01111101 00111100 10101010

ייצוג וחישוב על קבוצות • ייצוג • וקטור ביטים ברוחב w יכול לייצג תתי קבוצות של {0,…, w–1} • aj = 1 if jA 01101001{ 0, 3, 5, 6 } 76543210 01010101{ 0, 2, 4, 6 } 76543210 • פעולות • & Intersection 01000001 { 0, 6 } • | Union 01111101 { 0, 2, 3, 4, 5, 6 } • ^ Symmetric difference 00111100 { 2, 3, 4, 5 } • ~ Complement 10101010 { 1, 3, 5, 7 }

פעולות על ביטים ב C • הפקודות &, |, ~, ^ קיימות ב - C • רלבנטי לכל ה integers: • long, int, short, char • מופעל על המספר בייצוגו הבינארי • מופעל בנפרד על כל ביט • דוגמאות על משתנה מסוג char: • ~0x41 --> 0xBE ~010000012 --> 101111102 • ~0x00 --> 0xFF ~000000002 --> 111111112 • 0x69 & 0x55 --> 0x41 011010012 & 010101012 --> 010000012 • 0x69 | 0x55 --> 0x7D 011010012 | 010101012 --> 011111012 זכרו: 416=01002 116=00012

פעולות "זִיזַה" (shifting) Argument x 01100010 • הזזה שמאלה: x << y • הזז וקטור x שמאלה ב y מקומות • זרוק ביטים משמאל ומלא ב – 0 מימין • הזזה ימינה x >> y • הזז וקטור x ימינה ב y מקומות • זרוק ביטים מימין • שני מקרים: • הזזה לוגית (logical shift): מלא ב 0 משמאל • הזזה אריתמטית (arithmetic shift): שכפל הספרה השמאלית (msb). משתמשים בזה בייצוג 2’s complement שעוד נלמד. << 3 00010000 00010000 00010000 Log. >> 2 00011000 00011000 00011000 Arith. >> 2 00011000 00011000 00011000 Argument x 10100010 << 3 00010000 00010000 00010000 Log. >> 2 00101000 00101000 00101000 Arith. >> 2 11101000 11101000 11101000

כיצד נגלה את הביט ה -i • ערך הסיבית הימנית של int x: • int res; • res = x & 1; • מקובל להשתמש במסכות. מציאת הסיבית ה – k + 1 מימין: • int mask; • mask = 1 << k; • res = (x & mask) != 0;

ובניגוד לכך:פעולות לוגיות ב - C • פעולות לוגיות ב – C : • &&, ||, ! • ‘0’ מייצג שקר, '1' אמת • כל מספר שונה מ – 0 הוא 'אמת' • פעולה בוליאנית תמיד מחזירה 0 או 1 • דוגמאות על משתנה מסוג char: • !0x41 --> 0x00 • !0x00 --> 0x01 • !!0x41 --> 0x01 • 0x69 && 0x55 --> 0x01 • 0x69 || 0x55 --> 0x01 שימו לב להבדל בין ~ ל !

סיכום • הכל זה סיביות ובתים... • מספרים • תוכניות • טקסט • מחשבים שונים משתמשים בייצוגים שונים • רוחב מילה • סדר בתים • ייצוג • לוגיקה פסוקית מהווה כלי יסודי בהבנת פעולות המחשב • מצד אחד, היא מאפשרת חישובים מעל וקטורים של ביטים • מצד שני, ניתן לממש אותה בחומרה.

Bits and Bytes סיביות ובתים