שלום לכולם,

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

שאלתי היא:
במבנה הנתונים שאני בונה יש לי שדות שהם "בינאריים" כלומר: 0 או 1 ואני רואה שכל שדה כזה דורש 16 בתים בפני עצמו או 32 בתים כתא במערך (שזה המון...)
- האם יש דרך לשמור את המידע הזה בצורה שתחסוך זיכרון? (כל דרך אחר לייצג כן/לא גם תהיה בסדר לא חייב להיות 0 או 1)

תודה על העזרה,
סיון

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

ואם המשתנה מוגדר: bool $myVar ?

נמאס לכם לזכור סיסמאות? לחצו כאן!

אני מקבלת שגיאה כשאני מריצה.

אני לא מכירה את האפשרות להשתמש ב-bool
צריך בשביל זה לעשות use של איזה מודול?

תודה, סיון

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

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

חיפוש נוסף מראה שפרל בכלל לא מכירה את הקונספט של true ו false (איזו שפה הזוייה...) , לפחות בגירסא 5. מוזר.

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

עבור הביט הראשון (המשתנה הבינארי הראשון שלנו, לצורך העניין), 2 בחזקת 0 שווה 1
עבור הביט השני (המשתנה הבינארי השני שלנו, לצורך העניין), 2 בחזקת 1 שווה 2
עבור הביט השלישי (המשתנה הבינארי השלישי שלנו, לצורך העניין), 2 בחזקה 2 שווה 4

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

דוגמא:

קוד:

my $bitmarix;
$bitmatrix = $bitmatrix | 1;
$bitmatrix = $bitmatrix | 4;

וכדי לשלוף תכנותית ביט מסויים מהמשתנה שלנו, עושים AND לוגי של הנתון שאנחנו מחפשים (למשל - 4) מול המשתנה שמכיל את הביטים. אם הנתון היה 0, פעולת ה AND תחזיר 0. אם הוא היה 1, היא תחזיר מספר כלשהוא שונה מ 0, וכך אפשר לדעת, עם if פשוט.

דוגמא, אם אני רוצה לדעת אם הביט השלישי חיובי:

קוד:

if (($bitmatrix & 4) > 0) { printf("Bit 3 is, indeed, true!\n"); }

מקווה שזה עוזר...

נמאס לכם לזכור סיסמאות? לחצו כאן!

כן. חשבתי על זה...אבל זה יקשה עלי את החיפוש אח"כ.

למשל, אם יש לי שדה שאומר: האם שורה זו היא דחופה? (כן/לא) ויש לי שדה שאומר: האם שורה זו היא חריגה? (כן/לא) ואני רוצה לשלוף את כל השורות שהן דחופות (למשל)

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

אז כנראה שזה טריידאוף שאני אאלץ לנסות ולראות מה עדיף...

סיון

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

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

אגב... לטיפול בכמויות רציניות כאלה של מידע, אני באופן אישי הייתי משתמש במסד נתונים. בין אם משהו קל כמו SQLite או MySQL... גם אם כל המידע זמני, אפשר להשתמש במנוע של temporary tables שמחזיקות רק על ה session המסויים. מסדי הנתונים יאחסנו מידע באופן הרבה יותר יעיל, ככה"נ, מאשר פרל, וגם יאפשרו שימוש באינדקסים לחיפושים / חיתוכים מהירים מאוד.

אם ה logging מראש נעשה לתוך SQL, אז בכלל זה נחמד.

נמאס לכם לזכור סיסמאות? לחצו כאן!

הכי הרבה שהצלחתי לחסוך בזיכרון זה ככה:

קוד:

my $Zero=0;
my $UnpackedZero=unpack("S",0);

  

כשגודל הראשון הוא 16 בתים וגודל השני הוא 12 בתים (גם 4 בתים זה משהו )

אבל אני עדיין אשמח לרעיונות איך לשפר...

סיון

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

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

אפשר, למרות זאת, לממש Bit Vector ע"י פעולות בינאריות.
מה שעושים הוא שומרים מערך שבו כל תא שומר יותר מפריט מידע אחד:
אם מדובר ב-C למשל שם טיפוס נתונים של בית בודד נקרא char ושומר 8 ביט, אז אני שומר מערך של char-ים בגודל קטן פי-8 ממספר הדגלים שלי (מעוגל כלפי מעלה, כמובן) וכאשר אני רוצה לגשת לדגל ספציפי אני עושה זאת ע"י פעולה בינארית בשם AND.
רק כדי שיהיה ברור:

קוד:

0 AND 0 = 0
0 AND 1 = 0
1 AND 0 = 0
1 AND 1 = 1

נניח שיש לי את המספר הבינארי הבא: 10010110
אני מבצע לו AND עם המספר 00001000 (8 בבסיס עשרוני, 0x8 בבסיס הקסאדצימלי)
עבור כל סיבית מבוצע AND בנפרד והתוצאה:
10010110 AND
00001000
=======
0 = 00000000

אם הייתי עושה את פעולת ה-AND עם 00010000 התוצאה הייתה:
10010110 AND
00010000
=======
0 != 00010000

וכך למעשה קל למדי לבדוק את כל הדגלים:

קוד:

HEX	DEC	BIN
0x01	1	00000001
0x02	2	00000010
0x04	4	00000100
0x08	8	00001000
0x10	16	00010000
0x20	32	00100000
0x40	64	01000000
0x80	128	10000000

נשאר רק
1) להדליק דגל:
פעולה זו מתבצעת ע"י OR עם אחד הערכים שציינתי למעלה, הדגל המתאים ידליק את הסיבית המתאימה:
10010110 OR
00001000
=======
10011110

2) כיבוי דגל: פעולת AND עם ה-NOT של הערך המתאים:
10010110 AND
NOT 00010000
======= שקול ל:
AND 10010110
11101111
=======
10000110

מדוגמא ב-Perl שצרף מישהו מעלי, עושה הרושם שהכתיב פה זהה גם לזה של C:
AND מיוצג ע"י &
OR מיוצג ע"י |

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

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

נמאס לכם לזכור סיסמאות? לחצו כאן!

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

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