none
OutOfMemoryException מה עושים RRS feed

  • שאלה

  • שלום אני מנסה לכתוב תוכנית שבה אני משתמש במערך שגודלו עולה על זכרון ה - CACHE

    קימפלתי את התוכנית ל - 64 ביט + הקצאתי זכרון וירטואלי של עד 10 גיגה

    ועדיין אני מקבל OutOfMemoryException מה עוד אפשר לעשות?

    להלן התוכנית:

    double max = 0;
    try
                    {
    for (int power = 0; power < 29; power++)
                        {
                            max = Math.Pow(2, power);
                            double[] vectorOfElements = new double[(int)max];
     for (int i = 0; i < max; i++)
                            {
                                vectorOfElements[i] = (double)i;
                            }
    string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
                            Console.WriteLine("the power is"+power.ToString() +"size of array is " + max.ToString() +" RunTime " + elapsedTime);
                            GC.Collect();
                        }
    }
                    catch (InvalidCastException e)
                    {
                        Console.WriteLine("this is the exception: "+e.ToString());
                    

    יום חמישי 05 אפריל 2012 09:32

תשובות

  • זה סיקרן אותי יותר מדי אז מצאתי קוד שיפצרתי אותו והתאמתי אותו  ולבסוף הרצתי בדיקה וייצוג של מערך דומימדי עובד.

         DateTime dtStart = DateTime.Now;
                double max = 0;
                try
                {
                    for (int power = 0; power < 29; power++)
                    {
                        max = Math.Pow(2, power);
                        Console.WriteLine(max);
                        Console.WriteLine((Int64)max);
    
                        BigArray<double> baDouble = new BigArray<double>((ulong)max);
    
                        for (ulong i = 0; i < max; i++)
                        {
                            baDouble[i] = (double)i;
                        }
    
                        DateTime dtEnd = DateTime.Now;
                        TimeSpan ts = dtEnd.Subtract(dtStart);
    
                        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
                        Console.WriteLine("the power is" + power.ToString() + "size of array is " + max.ToString() + " RunTime " + elapsedTime);
                        Console.ReadKey();
                        dtStart = DateTime.Now;
                        // GC.Collect();
                    }
                }
                catch (InvalidCastException e)
                {
                    Console.WriteLine("this is the exception: " + e.ToString());
                }
            }
        }
    
        class BigArray<T>
        {
            // BLOCK_SIZE must be a power of 2, and we want it to be big enough that we allocate
            // blocks in the large object heap so that they don't move.
            internal const int BLOCK_SIZE = 524288;
            // Don't use a multi-dimensional array here because then we can't right size the last
            // block and we have to do range checking on our own and since there will then be 
            // exception throwing in our code there is a good chance that the JIT won't inline.
            T[][] _elements;
            ulong _length;
    
            // maximum BigArray size = BLOCK_SIZE * Int.MaxValue
            public BigArray(ulong size)
            {
                int numBlocks = (int)(size / BLOCK_SIZE);
                if ((ulong)(numBlocks * BLOCK_SIZE) < size)
                {
                    numBlocks += 1;
                }
    
                _length = size;
                _elements = new T[numBlocks][];
                for (int i = 0; i < (numBlocks - 1); i++)
                {
                    _elements[i] = new T[BLOCK_SIZE];
                }
                // by making sure to make the last block right sized then we get the range checks 
                // for free with the normal array range checks and don't have to add our own
                //_elements[numBlocks-1] = new T[NumElementsInLastBlock];
                _elements[numBlocks - 1] = new T[size - (ulong)((numBlocks - 1) * BLOCK_SIZE)];
            }
    
            public ulong Length
            {
                get
                {
                    return _length;
                }
            }
    
            public T this[ulong elementNumber]
            {
                // these must be _very_ simple in order to ensure that they get inlined into
                // their caller 
                get
                {
                    int blockNum = (int)(elementNumber / BLOCK_SIZE);
                    int elementNumberInBlock = (int)(elementNumber % (BLOCK_SIZE));
                    return _elements[blockNum][elementNumberInBlock];
                }
                set
                {
                    int blockNum = (int)(elementNumber / BLOCK_SIZE);
                    int elementNumberInBlock = (int)(elementNumber % (BLOCK_SIZE));
                    _elements[blockNum][elementNumberInBlock] = value;
                }
            }
        }

    • הוצע כתשובה על-ידי Ido Flatow. _Moderator יום חמישי 05 אפריל 2012 12:28
    • סומן כתשובה על-ידי just a question יום חמישי 12 אפריל 2012 09:53
    יום חמישי 05 אפריל 2012 11:25

כל התגובות

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

    כי ניסתי להשתמש ב 64 ביט וזה נתקע בלולאה ב 27

    נסיתי להפוך את המערך ל list וגם הוא נופל

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

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

    כמו כן בגרסה 4.5 יש אפשרות להקצות יותר מ 2 גיגה ע"י הוספת פרמטר מיוחד

    <configuration>
      <runtime>
        <gcAllowVeryLargeObjects enabled="true" />
      </runtime>
    </configuration>

    • נערך על-ידי tetitu יום חמישי 05 אפריל 2012 10:56 עוד קצת מידע
    יום חמישי 05 אפריל 2012 10:53
  • זה סיקרן אותי יותר מדי אז מצאתי קוד שיפצרתי אותו והתאמתי אותו  ולבסוף הרצתי בדיקה וייצוג של מערך דומימדי עובד.

         DateTime dtStart = DateTime.Now;
                double max = 0;
                try
                {
                    for (int power = 0; power < 29; power++)
                    {
                        max = Math.Pow(2, power);
                        Console.WriteLine(max);
                        Console.WriteLine((Int64)max);
    
                        BigArray<double> baDouble = new BigArray<double>((ulong)max);
    
                        for (ulong i = 0; i < max; i++)
                        {
                            baDouble[i] = (double)i;
                        }
    
                        DateTime dtEnd = DateTime.Now;
                        TimeSpan ts = dtEnd.Subtract(dtStart);
    
                        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
                        Console.WriteLine("the power is" + power.ToString() + "size of array is " + max.ToString() + " RunTime " + elapsedTime);
                        Console.ReadKey();
                        dtStart = DateTime.Now;
                        // GC.Collect();
                    }
                }
                catch (InvalidCastException e)
                {
                    Console.WriteLine("this is the exception: " + e.ToString());
                }
            }
        }
    
        class BigArray<T>
        {
            // BLOCK_SIZE must be a power of 2, and we want it to be big enough that we allocate
            // blocks in the large object heap so that they don't move.
            internal const int BLOCK_SIZE = 524288;
            // Don't use a multi-dimensional array here because then we can't right size the last
            // block and we have to do range checking on our own and since there will then be 
            // exception throwing in our code there is a good chance that the JIT won't inline.
            T[][] _elements;
            ulong _length;
    
            // maximum BigArray size = BLOCK_SIZE * Int.MaxValue
            public BigArray(ulong size)
            {
                int numBlocks = (int)(size / BLOCK_SIZE);
                if ((ulong)(numBlocks * BLOCK_SIZE) < size)
                {
                    numBlocks += 1;
                }
    
                _length = size;
                _elements = new T[numBlocks][];
                for (int i = 0; i < (numBlocks - 1); i++)
                {
                    _elements[i] = new T[BLOCK_SIZE];
                }
                // by making sure to make the last block right sized then we get the range checks 
                // for free with the normal array range checks and don't have to add our own
                //_elements[numBlocks-1] = new T[NumElementsInLastBlock];
                _elements[numBlocks - 1] = new T[size - (ulong)((numBlocks - 1) * BLOCK_SIZE)];
            }
    
            public ulong Length
            {
                get
                {
                    return _length;
                }
            }
    
            public T this[ulong elementNumber]
            {
                // these must be _very_ simple in order to ensure that they get inlined into
                // their caller 
                get
                {
                    int blockNum = (int)(elementNumber / BLOCK_SIZE);
                    int elementNumberInBlock = (int)(elementNumber % (BLOCK_SIZE));
                    return _elements[blockNum][elementNumberInBlock];
                }
                set
                {
                    int blockNum = (int)(elementNumber / BLOCK_SIZE);
                    int elementNumberInBlock = (int)(elementNumber % (BLOCK_SIZE));
                    _elements[blockNum][elementNumberInBlock] = value;
                }
            }
        }

    • הוצע כתשובה על-ידי Ido Flatow. _Moderator יום חמישי 05 אפריל 2012 12:28
    • סומן כתשובה על-ידי just a question יום חמישי 12 אפריל 2012 09:53
    יום חמישי 05 אפריל 2012 11:25
  • תודה רבה לך על העזרה. עוד לא בדקתי את התשובה עקב החג אבל אני באמת מעריך את העזרה

    חג שמח !!!

    יום ראשון 08 אפריל 2012 05:52
  • במידה וזה עזר לך אל תשכח לסמן את התגובה כתשובה :)

    חג שמח

    יום שני 09 אפריל 2012 06:49
  •   תודה ושוב חד שמח

        סימנתי כתשובה

    יום חמישי 12 אפריל 2012 09:53