אם יש ספק כוח עם זרם של 100A במסילות ה12V (ארבע מסילות של 25A), איך אני יכול לחשב מה ההספק המקסימלי שיכול להיות מסופק לרכיב על הלוח אם, למשל אם הוא מקבל וולט אחד ( למשל מעבד)? כלומר, כמה אמפרים כל וולט אחד מספק?

תודה

הכלל הוא V * A = W

המעבד שלך למשל במאמץ מקס' הוא 65W (את זה תמצא באתר של אינטל/AMD) והוא Vcore 1.3V אז הוא לוקח 50A מהמייצב שלו בלוח

המייצב בעצמו מעביר את אותם 65W אבל הוא עובד ב 12V - הוא לוקח 5.4A מהספק. במציאות המייצב לוקח גם משהוא לעצמו (לא הרבה) אז זה יהיה קצת יותר

הספק נניח מעביר 500W לכל המחשב והוא עובד ביעילות של 80% - כלומר מהחשמל שהוא לוקח 80% הם 500W שמגיעים למחשב ו 20% הם 125W שמתבזבזים. ביחד הספק לוקח מהחשמל 625W

נניח שהספק הוא אם Passive PFC וזה אומר שיש לו מקדם הספק של 1.4. ההספק המדומה שלו הוא 625*1.4 = 875VA

הממת בחשמל 240V כלומר הספק לוקח מהשקע 875/240 = 3.6A

תעשה את החישוב של ההספק בכל מקום שמעניין אותך

עכשו מה שאמרת שיש לספק 4 מסילות של 12V כלומר 100A ב 12V - לא בהכרח נכון ובדרך כלל לא נכון

לספק יש הגבלה מקס' של הספק לכל מתח והספק כללי

נניח למשל שהספק שלך הוא 1000W. ספק כזה לא יוכל לתת יותר מ 83A ב 12V בסך הכול (וזה בתנאי שלא מועמס כלום ב 5V ו 3.3V) ולא 100A

עכשו בהרבה ספקים כתוב מה ה W הכול המקס' שניתן לחבר לכל מתח. אם נניח ב 12V כתוב בסך הכול 60A או 720W, זה מגביל בהתאמה את מה שקורה אל המסילות. כלומר כל מסילה היא עד 25A אבל ביחד אסור שהם יגיעו או יעלו מעל משהוא קטן יותר מ 100W

תודה רבה

אם המעבד שלי צורך למשל 65W והvCore המקורי הוא 1.3V כמו שאמרת (סתם דוגמה), אז זה אומר שהוא לוקח 50A כמו שאמרת. אבל אם אני רוצה להעלות לו את המתח כי עשיתי OC למשל, ואני יודע שהוא צריך 90W למשל, אז אני מחשב את המתח שהוא צריך ככה: 90/50=1.8

? זאת אומרת שכמות האמפרים נקבעת בדיוק לפי המתח, כלומר במקרה שלנו כל 1.3V ייתן לי 50A, ואם אני אצטרך 130W אני צריך מתח של 2.6V? (סתם בתיאוריה, כי זה קצת לא הגיוני למעבד...)

כשאתה מעלה את המתח בהתנגדות קבועה, אתה מעלה בכך גם את הזרם. למשל :

יש לך נגד של 5 ohm שהיה מחובר ל 5V. הזרם 1A וההספק 5W

עכשו העלית את המתח ל 6V כלומר X1.2

הזרם תלוי במתח I = V/R ולכן גם הוא עולה X1.2 ועכשו הוא 1.2A

ההספק הוא P = I*V. גם המתח וגם ההספק עלו X1.2 ולכן ההספק עולה X1.2^2 ועכשו הוא 7.2W

כלומר ההספק עולה לא 1:1 אם המתח אלא בריבוע מכמה שעולה המתח

צריכת הזרם של המעבד תלויה בקיבול שלו (וזה קבוע לכל מעבד, תלוי במבנה הליבה וב nm, כש nm קטן יותר = פחות צריכת חשמל), ובקלוק שקובע כמה פעמים בשניה הוא מקבל את המטען שלו. בגדול ניתן להתייחס לזה כמו להתנגדות שיורדת ככל שמעלים את הקלוק, בערך 1:1 אם הקלוק

הספק בכללי הוא P = I*V. ו I = V/R כלומר הספק = P = V^2/R

ה "התנגדות" של המעבד במקרה שלנו תלויה בקיבול ובקלוק. ההתנגדות יורדת אם הקיבול ואם הקלוק כלומר R = 1/CF כש C זה נתון של קיבול של המעבד (ב uF/nF וכו) ו F זה הקלוק

ביחד אנחנו מקבלים ש P = V^2*F*C

עכשו נניח שהיה לך מעבד שעבד ב 2.4 GHz אם 1.3V ולקח 65W. אתה עשית OC ל 3 GHZ כלומר X1.25 והעלית מתח ל 1.4V כלומר X1.076 - לא נראה כזה הבדל גדול, כולה 0.1V

ההספק יעלה X1.25 מהקלוק ואז X1.16 מהמתח - ביחד 94.25W (ואם לא היית מעלה את המתח אז זה היה 81.25W - רואה את ההבדל ש 0.1V עושה ?)

אם נניח היית מעלה את המתח ל 1.8V, ההספק היה עולה כמעט X2 רק מהמתח עצמו - כנראה שהיית שורף את המעבד מיידית מהמתח וזה לפניי שבכלל עשינו OC

איך ולמה מעלים את המתח ?

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

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

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

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

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

ה flip flop מאפשר לייצב את הנתונים בקלט של המערכת הלוגית שעושה את החישוב. הקלט של ה flip flop יכול להשתנות ולקפוץ (למשל, היחידה שלפניי נמצאת באמצע חישוב והפלט שלה מכיל "מספרים רצים" שהם תוצאה של החישוב שעדיין רץ ולא את התוצאה הסופית), אבל הפלט שלו הוא "תמונה" דוממת, מה שאומר שהקלט של המערכת הלוגית שעליה הוא "מגן" יציב והיא יכולה לעשות את החישוב שלה בשקט בלי הפרעה. הפלט שלה מחובר ל flip flop של היחידה הבאה וכו

הקלוק מחובר לכל ה flip flopים במקביל. כלומר הקלוק אמור להיות מתוזמן כך שעד שהוא מגיע, כל היחידות סיימו את החישובים שלהם. כשהוא מגיע, כל flip flop קורא את הפלט של היחידה הקודמת (שעדיין יציב בגלל ה Tcd) ומעביר את התוצאה ליחידה הבאה

הזמן Tpd של היחידה האיטית ביותר הוא זה שקובע את הקלוק המקס' האפשרי. אם ננסה לתת למעבד קלוק מהיר יותר מידי, יקרה מצב שבו כשהקלוק מגיע היחידה הזאת עדיין לא סיימה את החישוב והפלט שלה מראה תוצאה של החישוב הקודם (שלא רלוונטי) או מספרים רצים (תוצאה של החישוב שעדיין לא סיים לרוץ), ה flip flop "יצלם" את מה שהוא רואה באותו רגע אבל זה הנתונים הלא נכונים, ומכאן נקבל שגיאות. ההמשך הוא קריסות ומסכים כחולים בגלל שהמעבד ביצע הוראות לא נכון, כי באחד מהשלבים של ה pipeline עברה תוצאת ביניים של חישוב במקום התוצאה הסופית הנכונה

אחת מהדרכים לקצר את ה Tpd (של כל היחידות) היא לעלות את המתח. זה גורם לשערים לוגיים לעבור מהר יותר ממצב למצב וכך הזמן שבו החישוב מסתיים מתקצר, וניתן להקדים את הקלוק הבא

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

אחת מהבעיות אם מתח גבוה יותר היא מחיקה של המוליכים מה "ציור" של הליבה של המעבד. הגודל של המוליכים הוא כמה עשרות nm וזה כבר לא רחוק מגודל של החלקיקים של החומר עצמו. אלקטרונים שעוברים בכוח גדול יותר (כי המתח גבוה יותר) יכולים לדחוף מהמקום חלקיקים של החומר, ובכך להעיף מהמקום חומר שממנו עשויים המוליכים בליבה - עד שבאחד מהמוליכים נוצר סדק (בשלב הזה המעבד מתחיל לעבוד פעם כן פעם לא), שמתפתח לחור (בשלב הזה המעבד לא עובד יותר)

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