תחומים - פורום חרדי מקצועי

@dovid אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

fork עשוי למקרה שאתה רוצה שכלל האפליקציה ירוץ במקביל על כמה מעבדים, כל אחד באופן די עצמאי.

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

@dovid אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

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

אני חושב שבמקרה שלי, החישובים הוא הפעולה הראשית ויהיה מורכב ומלוכלך לחלק אתם לתהליכים משניים
מה גם שמבדיקות שעשיתי, אין לי cpubloking רציני, פונקציות שהחשבתי למורכבות לוקחות כ-1ms
אבל גליתי משהו מעניין
שאם הרצת ה-db "קר", הוא תוקע את ה-cpu
כלומר החיפושים הראשונים איטיים עד שהוא "מתחמם" (תופס יותר cpu נראה לי), ואז הוא עובד מהר
היו לא מעט מקרים שהרצתי סידרת חיפושים ב-db
והפונקציה שרצה אחרי (אחרי שמתקבלות כל התשובות, לא הקול-בק שמפעיל הdb עם התשובה) מתעכבת לעיתים 100ms, שזה רוב רובו של זמן הרצת האפליקציה!

לפי זה דוד צודק שיעזור להוציא את ה-db להרצה נפרדת (את התקשורת אני מבצע באמצעות socket), זה אמור לחתוך את הזמן לרבע.
בבדיקה. אעדכן בל"נ.

שרת לינוקס ב-C9.
איך יתכן שסך כל עמודת ה-cpu הינו יותר מ-100%

דבר נוסף
מופעלים פה 2 ,תהליכים (שיוצרים מאזינים שונים) ע"י fork
האם אני צודק שזה יוצר רק "תהליך ילד" ולא תהליך מקביל ממש, ולכן הוא לא באמת מפעיל ליבה נוספת?
תראו איך זה נראה ב-2 הרצות ממש

@מנצפך אמר בשאלה כללית ב WebSocket:

https://stackoverflow.com/a/6756431
כאן יש אפשרות לעשות emit, ואז לחכות להאזין לתשובה שחוזרת.

Server

var io = require('socket.io').listen(80);

io.sockets.on('connection', function (socket) {
    socket.on("getSomeData", function (name, fn) {
        fn({ data: "some random data" });
    });
});

Client

    < script src = "http://localhost/socket.io/socket.io.js" ></script >
        <script>
            var socket = io.connect('http://localhost');
  socket.emit("getSomeData", function(data) {
                console.log(data);
            });
</script>

זה בגדול מה שחיפשתי. שימו לב שהקליינט שולח בקשה "getSomeDate", ומקבל את ה data שהוא רוצה.
פשוט וקל.

רק להוסיף
שאפשר גם לשלוח דאטא, רק לדאוג שהארגומנט האחרון יהיה הפונקציה

var socket = io.connect('http://localhost');
  socket.emit("getSomeData", 'this is data', function(data) {
                console.log(data);
            });

@shraga אמר בוידוא הריגה לכונן ssd שהפסיק לעבוד:
עשית לי חשק לנסות גם
איפה משיגים תושבת בזול?

עבודה עם TCP היא בדיוק אותו דבר למקומי ומרוחק.

רק שכותבים IP פנימי?

בד"כ כשבונים שתי מערכות נוד באותה מכונה יש צורות תקשורת שעוטפים את הTCP ומקילים את החיים, למשל כמו ZeroMQ.

אנסה ללמוד אותו.

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

כפל של אותו של אותו קובץ
אבל אפשר לתת שם לכל פורק ואז להכניס התניה לפי השם.

לעבוד עם Workers שזה נשמע לי טבעי יותר לסוג האפליקציה שלך.

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

מאמר מעניין
https://nodejs.org/en/docs/guides/dont-block-the-event-loop/

אין ברירה, אשאל שאלות של מתחיל

אני מריץ נוד שמקים שרת

var http = require('http');
server.listen(8080, "0.0.0.0", function(){})

זה אומר שנוד נרשם במע' ההפעלה שכל קריאה שנכנסת מבחוץ (כרטיס הרשת) שיעודה פורט 8080 (ע"י כתיבה מפורשת, או ניחוש לפי הפרוטוקול) תשודר לתהליך הנוד.
עד לכאן הבנתי נכון?

נסיתי להקים שרת חדש (= האזנה חדשה) לאותו פורט אך ב-IP שונה ועלתה לי הודעת שגיאה שזה דורס תהליך קיים.
אך פורט אחר עם אותו IP כן התקבל.

משמע שהניתוב הפנימי מבוצע רק ע"י הפורט, אז למה משמש כתובת ה-IP?

שאלה נוספת "לוקל הוסט" הוא סכ"ה משתנה המכיל כתובת IP פנימי מוסכם?

העלות של החלוקה לליבות לא ראויה לציון לדעתי (כל עוד יש cpu blocking באפליקציה).

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

מה בדיוק השאלה?
בדרך כלל בכל אופן משתמשים בספריות מוכנות אבל לא הבנתי מה שאלתך.

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

proccess נפרד לגמרי. פשוט שירות נוד שיטפל רק בנתונים.

fork לא פותח proccess נפרד לגמרי?? ממה שקראתי הוא גם משכפל מופעים של נוד.

@dovid אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

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

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

@dovid אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

כתובת לוקלית זה מבודד עוד יותר.

איך יוצרים כתובת לוקלית ו\או תקשורת TCP ב-nodejs ל-DB?
וכתובת לוקלית מבודדת יותר ממה?

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

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

@dovid אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

בDB אחרים ישנה תוכנה שרצה על אותו המחשב או על אחר (עוד יותר יעיל) והיא מאזינה לרוב בפרוטוקול TCP ובכתובת פנימית.
זה מפזר את ההתקנה והתחזוקה של האפליקציה על פני שתי נושאים: שירות הנתונים, והאפליקציה עצמה.

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

מצד שני זה שונה מ-

@dovid אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

אלא שיש סוג נוסף שנקרא Embedded Databases שזה בעצם אומר שהקוד שלך הוא עצמו שרת הנתונים (אלא שהוא משתמש עם ספריה בשביל כל המורכבות של השמירה והשליפה וכו'). יש לזה מעלות אבל גם חסרונות בדיוק מסוג הדילמה שלך כעת.

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

@אהרן אמר בלהגדיר את levelUp db כserver נפרד שמקשיב לארוע, כיצד, והאם כדאי?:

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

זה מה שהמודול הזה עושה? מוזר שהא לא מעודכן מ-2014.

אני רוצה לשכפל את האפליקציה כפי כמות הליבות במעבד, ע"י cluster.fork()

הבעיה שאני משתמש ב-levelUp db שא"א לשכפל מופעים שלו (אחרי יצירת מופע אחד הגישה לקבצים ננעלת).

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

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

ועוד שאלה שלא נוגעת ישירות
כשnodejs שולח שאילתה ל-db שהוא תוכנה חיצונית הכתובה ב-c, ה-db מפעיל תהליך חדש ונפרד מהתהליך שבו רץ nodejs?

@dovid אמר בדיון בנושא הביצועים בJS:

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

איפה יש דוגמאות קוד נירחבות יותר?

כאן יש דיון מרתק על שימוש מאסיווי ב-CPU בנוד (זה מרתק כי לא הבנתי שם מילה).

וכמו שכתוב שם כאן יש השוואה בין שיתוף פרוססים לשיתוף תהליכים.

מישהו ניסה א"ז?

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

@dovid אמר בדיון בנושא הביצועים בJS:

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

NO

@dovid אמר בדיון בנושא הביצועים בJS:

כל פעם שאתה עושה = למשתנה, תוכנו מחלף לחלוטין בין אם הוא מצביע בין אם הוא ערך.
השאלה עם contact לא הבנתי.

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

var arr = []
var obj = {} / or newArr
obj.arr = arr
arr.push('hi')

obj.arr[0] == 'hi'
--
arr = ['test']
obj.arr[0] != 'test'
אותו דבר
arr.contact(nreArr)
obj.arr[0] != 'test'

@dovid אמר בדיון בנושא הביצועים בJS:

דחיפת איברים חדשים מהירה יותר במערך (טסט).

הטסט מפנה לטסט obj vs arr insertion.

@dovid אמר בדיון בנושא הביצועים בJS:

תודה רבה רבה! עדכנתי את הפוסט.

עדיין כתוב שזה מהיר יותר.

Footnotes >> Endnotes.

ממיר הערות סקירה להערות שוליים

Sub commntv()
For Each comm In ActiveDocument.Comments
comm.Reference.Select
Selection.Footnotes.Add Range:=Selection.Range, Reference:="", Text:=comm.Range.Text
comm.Delete
Next
End Sub

איך אני ממיר להערות סיום?

@dovid אמר בדיון בנושא הביצועים בJS:

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

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

@dovid אמר בדיון בנושא הביצועים בJS:

יש פה שתי חלקים:

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

@dovid אמר בדיון בנושא הביצועים בJS:

למה זה כה מורכב? כל ערך פרימיטיבי = לא אובייקט (number, string, bool), מועבר כעותק. כל אובייקט (שזה כולל פונקציה ומערך שכן הם גם אובייקטים) מועברים כמצביע.

ומה קורה אם אתה מתאחל את האוביקט, מגדיל את המערך ע"י concat (הגיוני לרצות לחסוך לולאה)?

@dovid אמר בדיון בנושא הביצועים בJS:

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

אתה כנראה מתכוון למקרה ומשתמשים בכל הנו.. התיבות.

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

התשובה היא אולי

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

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

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