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

@דוד ל.ט.

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

באמת בדקתי וקריאה רצופה מהירה פי מאה מקריאה עם העברת מצביע כל פעם!

Dim MAX As Integer = 2000000
    Dim SW As New Stopwatch

    Dim ARR(MAX) As Integer

    Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
        'בניית הקובץ
        SW.Reset()
        SW.Start()

        Dim BW As New BinaryWriter(File.Open("C:\SS.TXT", FileMode.Create), Encoding.UTF8)
        For I = 2 To MAX + 2
            BW.Write(CInt(I))
        Next
        BW.Close()

        SW.Stop()

    End Sub

    Private Sub Button2_Click(sender As System.Object, e As System.EventArgs) Handles Button2.Click

        SW.Reset()
        SW.Start()

        Dim BR As New BinaryReader(File.OpenRead("C:\SS.TXT"), Encoding.UTF8)
        Dim num As Integer = MAX
        'קריאה רצופה
        For I = 0 To MAX

            'קריאה עם דילוג כל פעם
            'For I = MAX * 4 To 0 Step -4
            '    BR.BaseStream.Position = I

            ARR(num) = BR.ReadInt32
            num -= 1
        Next

        BR.Close()

        SW.Stop()

    End Sub

פורסם במקור בפורום CODE613 ב04/07/2013 21:46 (+03:00)

@דוד ל.ט.

יש לי על היישום כמה הערות

אשמח לשמוע ולהחכים.

@דוד ל.ט.

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

שים לב שאין אני רוצה לאתחל מערך עם כל המילים אלא לעבור על כל המילים ישירות על הדיסק כעצתך לעיל וממילא אני מוכרח לכתוב בעצמי פונקציה לחיפוש בינארי זה. יש עוד שיטה לחיפוש בינארי כאן:
http://vlib.eitan.ac.il/ds1/block_find.htm

פורסם במקור בפורום CODE613 ב04/07/2013 20:37 (+03:00)

@דוד ל.ט.

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

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

@דוד ל.ט.

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

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

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

לדעתי זה יהיה ממש מהיר לא ?

פורסם במקור בפורום CODE613 ב04/07/2013 14:44 (+03:00)

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

ב. לגבי האינדקס יוצא שאתה עושה את הספירה כמה פעמים כל מילה מופיעה תוך כדי חיפוש וזה לוקח זמן, אולי עדיף שכל מילה תופיע באינדקס כמספר כמו שאמרת, אבל רק פעם אחת ולצידה יופיעו מספרים שמציינים את מיקומי המילה בקובץ למשל תופיע מילה 'שלום' אבל לא כשלום אלא כמספר נאמר 20 כיון שזה המזהה של המילה 'שלום' במילון ואחר המספר 20 יופיע רצף של מספרים למשל 40 500 780 שזה אומר שהמילה 'שלום' מופיעה בקובץ המקורי כמילה ה 40 מתחילת הקובץ וכמילה ה500 מתחילת הקובץ וכו'.

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

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

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

פורסם במקור בפורום CODE613 ב04/07/2013 12:38 (+03:00)

אני אבהיר את הדברים יותר:

א. נאמר שיש לי חמישה קבצים ונאמר שכל קובץ מכיל חומש מהתורה.

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

ג. המשתמש מחפש כמה מילים עם מרחק מקסימלי בינהם, השאילתא יכולה להראות כך:
שלום {30} ברכה {11} הצלחה {22} שמחה

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

ה. אני קורא מהאינדקס כל פעם כמה ביטים ומאתחל מערך שמכיל כנ''ל רשימת מילים והמיקומים שלהם, לאחר שיש לי מערך אני עובר עליו פעם אחת עבור כל מילה [לא על כולו ממש אלא על אחד חלקי 22 ממנו כי הוא ממויין לפי א''ב] ואז בוחן אם כל המילים שמצאתי מספיק קרובות אחת לשניה. ואז אני עובר לאינדקס הבא ומאתחל מערך חדש וחוזר חלילה.
זהו.

כמובן שיש גם שאילתות עם כוכביות כמו:
שלום {30} ברה {11} הצלה {22} שמח
אם אני לא אמיר את כל הקובץ לטקסט איך יהיה אפשר לחפש?

כעת מה כאן מיותר, לא נכון, וכדומה. ואיך נכנס לכאן המסד נתונים אם בכלל.

פורסם במקור בפורום CODE613 ב03/07/2013 19:06 (+03:00)

אבל זה בדיוק מה שעשיתי עד כעת!
וכמו שהסברתי לעיל שיש קובץ אינדקס שבו 200 אלף ביטים ראשונים שייכים לאוביקט סיכום של קובץ א' ואח''כ 150 אלף ביטים שייכים לאובייקט סיכום של קובץ ב' וכן על זה הדרך מאות ואלפי אובייקטים של סיכומי קבצים, וכשאני רוצה לחפש מילים בקובץ א' אני ניגש לתחילת המערך וקורא עד 200 אלף וכשאני צריך לחפש בקובץ ב' אני קורא מביט 200001 עד 350000 וכך מאתחל את האובייקט. וכן על זה הדרך.
ואם רוב הזמן הולך לא על קריאת הביטים מהדיסק אלא בהמרה של ביטים למחרוזות איך הם עושים את ההמרה מהר?

פורסם במקור בפורום CODE613 ב03/07/2013 11:39 (+03:00)

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

פורסם במקור בפורום CODE613 ב02/07/2013 20:42 (+03:00)

את הסירילזציה הזו אני כבר ניסית והיא יוצרת קובץ פי כמה יותר גדול וגם בפי כמה יותר זמן ממה שאני עשיתי כנ''ל.
וגם את protobuf-net ניסיתי ואף שהוא הרבה יותר מהיר מה BinaryFormatter עדיין מה שעשיתי כנ''ל הרבה יותר מהיר גם ממנו.
וזה מה שעשיתי בתחילה: וזה הרבה יותר איטי וגם אתה חייב לקרוא את כל הקובץ בבת אחת ללא יכולת לדלג לאוביקט שנמצא במקום אחר בקובץ

Public Sub Save(Obj As Object, Filename As String)
    Dim File As FileStream = New FileStream(Filename, FileMode.Create)
    Serializer.Serialize(File, Obj)
    File.Close()
End Sub

Public Sub Load(Of T)(aFilename As String, ByRef Obj As T)
    Dim File As FileStream = New FileStream(aFilename, FileMode.Open)
    Obj = Serializer.Deserialize(Of T)(File)
    File.Close()
End Sub

פורסם במקור בפורום CODE613 ב02/07/2013 20:21 (+03:00)

תודה רבה, בע''ה אני אנסה ואעלה לכאן את התוצאות....

פורסם במקור בפורום CODE613 ב02/07/2013 18:42 (+03:00)

מדובר באינדקס של תוכנת חיפוש
כלומר אני סורק קבצים ולכל קובץ אני בונה אובייקט שמכיל את כל המילים שיש בקובץ שזה בעצם מערך של מחרוזות ועוד כמה פרטים כמו שם הקובץ ותאריך כניסה לאינדקס וכדומה.
אח''כ אני שומר אותו בדיסק, כך קובץ אחר קובץ אני סורק ושומר את הסיכום שלו בדיסק ע''י הפקודה Write עבור כל איבר באוביקט הנ''ל, התוכנית כתובה ב VB של דוטנט.

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

פורסם במקור בפורום CODE613 ב02/07/2013 18:00 (+03:00)

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

פורסם במקור בפורום CODE613 ב02/07/2013 15:45 (+03:00)

דוד, מדריך נפלא!!

פורסם במקור בפורום CODE613 ב09/02/2014 18:57 (+02:00)