ממש לא.

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

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

דוגמא לקטע מאלגוריתם (בצורה מופשטת מאד):

-מדוד זמן שעבר מאז הפריים הקודם.

-בדוק את מיקום הקליע.

-הזז אותו בכמות פיקסלים ביחס לזמן.

-בדוק האם הוא פוגע ביריב.

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

אז מה שיקרה, אם היתה חלוקה אוטומטית של האלגוריתם, זה שליבה אחת תעשה:

מדוד זמן...

הזז את הקליע... (מאיפה?!)

והליבה השניה תעשה באותו זמן:

בדוק מיקום...

בדוק פגיעה... (במיקום הקודם)

זה כמובן הפך את האלגוריתם לשני אלגוריתמים חסרי משמעות.

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

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

לא המשחק Prey ולא FarCry משתמשים בCUDA.

^^^^^

זה נכון מאוד, אבל לא כל כך מדוייק.

עבור כמות מספקת של ליבות, ניתן "לספוג" את ה-Overhead של מנוע שמפצל עבודה בין הליבות. כלומר, מה שמפוצל בין הליבות הוא Data שצריך לעבוד עיבוד.

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

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

צירפתי כמה תמונות וחלק קטן מאוד מהקוד, אגב: הקוד כתוב בשפת coffee שהיא המגבילה של C++ CINEMA 4D.

אוי.. איך אני מתגעגע לתקופה הזאת

המעבד לא מחכה לסיום של רינדור פריים ואז שולח פקודות.

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

לבאפר הזה קוראים Z-Buffer+Frame Buffer, בזמן שהכרטיס מרנדר פריים יש לו כבר פריים נוסף במצב של וורטקסים בבאפר מוכן לרינדור.

סתכלו בתמונות:

1. הפריים של המשחק מוכן במצב של וורטקסים, כולל מיפוי טקסטורה תאורה וצללים.

2. תמונה מימין, המצב של כול השלב במשחק ממבט על שטח מעורך של הטירה כ-1-2 דונם.

3. פריים מרונדר בגבולות המצלמה של השחקן

4. דוגמה לחלק מהקוד:

/****************************************************************

* *

* 3D Vector *

* *

****************************************************************/

class vec3

{

protected:

double n[3];

public:

// Constructors

vec3();

vec3(const double x, const double y, const double z);

vec3(const double d);

vec3(const vec3& v); // copy constructor

vec3(const vec2& v); // cast v2 to v3

vec3(const vec2& v, double d); // cast v2 to v3

vec3(const vec4& v); // cast v4 to v3

vec3(const vec4& v, int dropAxis); // cast v4 to v3

// Assignment operators

vec3& operator = ( const vec3& v ); // assignment of a vec3

vec3& operator += ( const vec3& v ); // incrementation by a vec3

vec3& operator -= ( const vec3& v ); // decrementation by a vec3

vec3& operator *= ( const double d ); // multiplication by a constant

vec3& operator /= ( const double d ); // division by a constant

double& operator [] ( int i); // indexing

double operator[] (int i) const; // read-only indexing

// special functions

double length() const; // length of a vec3

double length2() const; // squared length of a vec3

vec3& normalize(); // normalize a vec3 in place

vec3& apply(V_FCT_PTR fct); // apply a func. to each component

// friends

friend vec3 operator - (const vec3& v); // -v1

friend vec3 operator + (const vec3& a, const vec3& b); // v1 + v2

friend vec3 operator - (const vec3& a, const vec3& b); // v1 - v2

friend vec3 operator * (const vec3& a, const double d); // v1 * 3.0

friend vec3 operator * (const double d, const vec3& a); // 3.0 * v1

friend vec3 operator * (const mat4& a, const vec3& v); // M . v

friend vec3 operator * (const vec3& v, const mat4& a); // v . M

friend double operator * (const vec3& a, const vec3& b); // dot product

friend vec3 operator / (const vec3& a, const double d); // v1 / 3.0

friend vec3 operator ^ (const vec3& a, const vec3& b); // cross product

friend int operator == (const vec3& a, const vec3& b); // v1 == v2 ?

friend int operator != (const vec3& a, const vec3& b); // v1 != v2 ?

#ifdef ALGEBRA3IOSTREAMS

friend ostream& operator << (ostream& s, const vec3& v); // output to stream

friend istream& operator >> (istream& s, vec3& v); // input from strm.

#endif // ALGEBRA3IOSTREAMS

friend void swap(vec3& a, vec3& b); // swap v1 & v2

friend vec3 min(const vec3& a, const vec3& b); // min(v1, v2)

friend vec3 max(const vec3& a, const vec3& b); // max(v1, v2)

friend vec3 prod(const vec3& a, const vec3& b); // term by term *

// necessary friend declarations

friend class vec2;

friend class vec4;

friend class mat3;

friend vec2 operator * (const mat3& a, const vec2& v); // linear transform

friend vec3 operator * (const mat3& a, const vec3& v);

friend mat3 operator * (const mat3& a, const mat3& b); // matrix 3 product

};

לכול מי שמתעניין בתחום, אני ממליץ על הספר הזה:

http://www.amazon.com/Beginning-DirectX-9-Game-Development/dp/1592003494/ref=si3_rdr_bb_product/104-6556776-4676725

[attachment deleted by admin]

אני חושב שכתבתי תגובה בתר'ד הלא נכון, טוב.. אז הינה דעתי בנושא:

http://hwzone.co.il/community/index.php?topic=220174.msg1933974#msg1933974

אני חושב שכתבתי תגובה בתר'ד הלא נכון, טוב.. אז הינה דעתי בנושא:

http://hwzone.co.il/community/index.php?topic=220174.msg1933974#msg1933974

מה שמצחיק הוא, שאתה פותח את הדברים שלך שם ב"אתם מבולבלים פה לגמרי"

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

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

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

בכלאופן, אנחנו בכלל לא טועים.

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

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

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

לא המשחק Prey ולא FarCry משתמשים בCUDA.

איזה משחקים אז אן יתמכו בCUDA? כבר יודעים?

CoolOne אחי את ההסבר שלך הכי הבנתי.. וסוףסוף הבנתי למה צריך לתכנן שהמשחק יעבוד בשתי ליבות.. וסתם ככה הוא לא יעבוד..

אבל.. יש מצב שהמעבדים היו יכולים לנצל בלי תיכנון מיוחד למשחק שיעבדו עם כפולי ליבה למשל..

במשחק אסטרטגיה, כל ליבה תחשב מה שקורה בחלק מהמפה (או מהמסך).

ואז זה לא משנה מה עובד קודם.. ואז ישר המשחק יכול להשתמש בשתי ליבות ליבה אחת תחשב חלק אחד של מפה וליבה שניה חלק אחר..

יכול לקרות כזה דבר?

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

או שיש דברים שגם אם לא תיכנן זה ינצל את המרובעי ליבה?

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

או שיש דברים שגם אם לא תיכנן זה ינצל את המרובעי ליבה?

היום הרוב המוחלט של המשחקים מתוכנתים לנצל מעבדים כפולי ליבה. באלגוריתמים המתוכננים ל2 ליבות *אני מניח ש*לא צריכה להיות בעיה כ"כ לפצל ל4 ליבות.

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

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

PerGola: משחקים תומכים בCUDA? אין לי רשימה... אני מניח שבין המשחקים יהיה Crysis.

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

כרגע שימוש במס' מוגדר מראש של ליבות הוא יעיל הרבה יותר, וסביר להניח שמשחק שמותאם ל2 ליבות לא ישתמש ב-4 ליבות גם אם יהיו לו זמינות, אלא אם יתאימו את המשחק במיוחד גם ל4 ליבות.

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

חשבתי על זה עוד קצת..

ובעיקרון הרי תקיעות במשחקים יהיו רק מ 25 20 FPS

לפי הגרף E6300 ב PREY הגביל רק מ125FPS

FARCRY הגביל מ90FPS שהרי הוא צריך עיבוד חזק יותר..

ובטח משחקים עם עיבוד חזק יותר כבר מגבילים מ70FPS

ומשחקים עתידיים עם הרבה יותר עיבוד כבר בטח 50 40.. אני לא מאמין שפחות

וכל עוד זה לא מגיע להגבלה ב20 25FPS לא נשים לב להבדל..

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

וגם כשזה יקרה יש שני פתרונות

1. הCUDA משחקים עד אז כבר ינצלו את הטכנולוגיה הזאת וירד חלק ניכר מעבודת המעב דואז הוא לא יגביל

2. כרטיסי הפיזיקה שכנ"ל יורידו חלק ניכר מהעבודה של המעבד..

בקיצור אני לא חושב שיש טעם לקנות מעבד חזק יותר מE6300

ולמי שעושה OC אין טעם לחזק יותר מE6400 (אלא אם משתמש בקירור גז או מים)

מה אתם אומרים?

אל תדאג יצליחו לנצל את הכח של המעבדים.

בינה מלאכותית חכמה הרבה יותר ועולם משחק גדול יותר ואינטראקטיבי יותר...

אין דבר כזה "יותר מדי" כוח עיבוד...