עידכונים מ - jungo

[בוגר26]

אתמול כשלתי חזק ב JUNGO ,
בכל מקרה הנוסח של שאלת הMALLOC התעדכן קצת ממה שמתואר פה אז חשבתי לעדכן -
הומצאה מערכת הפעלה ובה 4 פונקציות סיפרייה חדשות -
mallocbig
mallocsmall
freebig
freesmall
ה BIG נועדו להקצות ולשחרר בלוקים של מעל 512K והSMALL נועדו להקצות ולשחרר כל מה שמתחת ל 512K .
שתי פונק' ההקצאה הנ"ל לא מסוגלות לקבל מספרים שהם לא כפולה של 16 , כלומר מקצות רק בלוקים של כפולות של 16 .
עכשיו בשימוש ב 4 הנ"ל - צריך לממש שתי פונ' - MALLOC הרגילה - שיכולה לקבל כל גודל של בלוק , ובעיקר של בלוקים שלא מתחלקים ב 16 . ו FREE הרגילה - כאשר יש לשים לב שכל בלוק משוחרר בהתאמה לפונ' שהקצתה אותו .
בהצלחה !

[אבג]

זה שלב א'.מישהו היה בשלב ב'

[מועמד]

לישהו יש פתרון לשאלה הזו?

תודה מראש!

[אורח]

void * my_malloc(int sz)
{
extern void *OS_malloc_big(int sz);
extern void *OS_malloc_small(int sz);

int *tmp, div;

if(sz<0)
return NULL;

sz += sizeof(int);

if(sz <= 512)
{
if(sz%16)
{
div = sz/16+1;
tmp = (int*)OS_malloc_small(div*16);
*tmp = div*16;
tmp++;
return (void*)tmp;
}
tmp = (int*)OS_malloc_small(sz);
*tmp = sz;
tmp++;
return (void*)tmp;
}
if(sz%16)
{
div = sz/16+1;
tmp = (int*)OS_malloc_big(div*16);
*tmp = div*16;
tmp++;
return (void*)tmp;
}
tmp = (int*)OS_malloc_big(sz);
*tmp = sz;
tmp++;
return (void*)tmp;
}

void my_free(void *p)
{
extern void OS_free_big(void *p);
extern void OS_free_small(void *p);

int *tmp = (int*)(p);

tmp--;

if(*tmp<=512)
{
OS_free_small(tmp);
}
else
{
OS_free_big(tmp);
}
}

[id2008]

ניתן לפשט את my_malloc , להוסיף מקרה קצה בו size==0 , ולמנוע
שכפול קוד - את החישוב הכפול של div = sz/16+1 :

קוד: בחר הכל

void* my_malloc(int size)
{
   int new_size;
   int *tmp;

   if(size<=0)
      return NULL;

   size+=sizeof(int);
   new_size=((size/16)+1)*16;

   if(new_size<=512)
      tmp=(int*)malloc_small(new_size);
   else
      tmp=(int*)malloc_big(new_size);

   *tmp=new_size;
   tmp+=sizeof(int);

   return (void*)tmp;
}

[אורח_פורח]

מישהו יודע מה שואלים בראיון השני בג'נגו?

[חבר]

חבר'ה מי היה לאחרונה ויכול לעדכן לגבי הראיון השני?

[איציק]

אני הייתי ממליץ לכולם להיכנס רגע לאתר הבא http://smartkitchens.wordpress.com

מקסים ויפה...

[12novice]

מישהו יכול להסביר לי למה בפתרון מופיע (size+=sizeof(int ?

[סתם אחד]

void* my_malloc(int size)
{
int new_size, div;
void* ptr = NULL;

if(size<=0) return NULL;

/*
//the usage og sizeof(int) is for knowing the actual size we allocate, we need this information
//later on my_free function
*/

size = size + sizeof(int) + 16;
div = size % 16;
new_size = div * 16;

if(new_size <= 512) ptr = small_malloc(new_size);
else ptr = big_malloc(new_size);

*((int*)ptr) = new_size;
((int*)ptr++);

return ((void*)ptr);
}

void my_free(void* ptr)
{
int size;

size = *((int*)--ptr);

if (size <= 512) small_free(ptr);
else big_free(ptr);
}

[אורח]

בשני הפתרונות האחרונים יש טעות קטנה . האחרון מחשב div*16 שזה בעצם השארית מהחלוקה ב16 וזה שכתב לפניו רשם new_size=((size/16)+1)*16; מבלי לבדוק האם הגודל מתחלק ב 16 ואז למשל אם size==16 אנחנו נקצה 32 בתים ( 2 בלוקים) במקום 16 בלבד.
בהצלחה

[רון]

הי,

הייתי בראיון ב JUNGO.

"הסיפורים" עליהם "בערך" נכונים.

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

מאחר וראיתי את כל השאלות שהיו בפורום לגבי חבר'ה שהתנסו ב JUNGO – הכנתי לי (מבעוד מועד) תוכניות ב C (ע"ג Linux – יכול להיות שב- Windows צריך לעשות includeים קצת אחרים) שפותרות את הבעיות האלה – כדי שלא יהיה מצב שאני כותב משהו שלא מתקמפל/רץ נכון.



צירפתי ת'קבצי C,H הרלוונטים כדי שכ"א יוכל להתרשם ולהבין:

1. בקבצי ה- aligned_malloc.* יש פתרון לבעיית ה- aligned malloc הידועה:

a. יש להם טוויסט חדש – לפחות בשבילי זה היה חדש – הם רוצים שהבלוק שמוקצה יהיה מאותחל לאפס – אז הוספתי לולאת for שמאפסת אותו – לא ידעתי אם מותר להשתמש ב- memset(…).

b. העיקרון המנחה כאן הוא לשמור את ה- offset לתחילת הבלוק המוחזר (מתחילת הבלוק שהוקצה) ע"י unsigned char (כדי שזה "יכנס" ב- byte 1) ולזכור בדיוק את המיקום שלו...

c. נ.ב. – בגלל שזה unsigned char – זה (ה- offset) לא יכול להיות > 255...

2. בקבצי ה- multiple_malloc.* יש פתרון לבעיית ה aligned malloc "ההפוכה":

a. נתונות 2 פונ' malloc: big_malloc (עבור בלוקים > 512), small_malloc (עבור בלוקים שאינם > 512). 2 פונ' אלו מקצות בלוקים בגדלים של כפולות שלמות של 16.

b. נתונות 2 פונ' free: big_free (עבור בלוקים > 512), small_free (עבור בלוקים שאינם > 512).

c. כעת צריך לממש פונ' malloc & free סטנדרטיות שיכולות להקצות/לשחרר כל גודל.

d. המוטיבציה ל"המציא" שאלה כזאת כנראה מגיעה מ- embedded – שם יכול להיות מצב שבו בלוקים "גדולים" "לוקחים" ממקום אחד ובלוקים "קטנים" ממקום אחר...

e. העיקרון המנחה כאן מתחלק לכמה חלקים:

i. כאשר מקצים בלוק – צריך "לזכור" האם הוא גדול/קטן (כי אח"כ אנחנו צריכים להשתמש בפונ' free המתאימה).

ii. אם רוצים להקצות בלוק בגודל X כלשהו – צריך למעשה למשתמש בפונ' malloc הרלוונטית עבור בלוק שגודלו = הכפולה השלמה של 16 הקטנה ביותר שהיא עדיין > X (יעני בקיצור: הכפולה השלמה של 16 "הראשונה" אחרי X).

3. בקבצי ה- my_timer.* יש פתרון לבעיית "בניית ספריית scheduler":

a. צריך לממש 2 פונ': add_timer (מוסיפה אלמנט ל database שמכיל פוינטר לפונ' וזמן שבו צריך להריץ ת'פונ' הזאת), run_timers (פונ' שעוברת על ה- database הזה מריצה את הפונ' לפי סדר הזמנים).

b. יעני מובטח לך שאחרי שמריצים את run_timers, יותר לא קוראים ל add_timer.

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

d. העיקרון המנחה כאן הוא database של רשימה מקושרת ממויינת לפי הזמן (ואז אפשר להריץ כל פונ' מבלי "לקפוץ" קדימה/אחורה...).



השאלות האלה יכולות לעזור גם לחבר'ה שלא "הולכים" ל- JUNGO – יש כאן אלמנטים בסיסיים חשובים שכדאי לזכור אותם לפני שניגשים לראיון אצל חברה עם מוצר embedded...

[אופירס]

שלום,

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

תודה, אופיר.

[יעקוב]

אופיר, אתה יכול בבקשה להגיד מה שאלו אותך בראיון הראשון ?

תודה.

[ממליץ1]

לבחור שעבר ראיון ראשון - חבל לך על הנסיעות לנתניה ... ביזבוז זמן !

ממליץ לך לוותר על התענוג ולא ללכת לראיון - הם בכלל לא מגייסים, סתם מראיינים אנשים !