初始化对象时的内存消耗

Question

I am trying to build some objects and insert them into a database. The number of records that have to be inserted is big ~ millions. The insert is done in batches. The problem I am having is that i need to initialize new objects to add them to a list and at the end, i do a bulk insert into the database of the list. Because i am initializing a huge number of objects, my computer memory(RAM) gets filled up and it kinda freezes everything. The question is : From a memory point of view, should I initialize objects of set them to null ? Also, I am trying to work with the same object reference. Am i doing it right ?

Code:

QACompleted completed = new QACompleted();
QAUncompleted uncompleted = new QAUncompleted();
QAText replaced = new QAText();

foreach (QAText question in questions)
{
    MatchCollection matchesQ = rgx.Matches(question.Question);
    MatchCollection matchesA = rgx.Matches(question.Answer);

    foreach (GetKeyValues_Result item in values)
    {

        hasNull = false;
        replaced = new QAText();  <- this object

        if (matchesQ.Count > 0)
        {
            SetQuestion(matchesQ, replaced, question, item);
        }
        else
        {
            replaced.Question = question.Question;
        }

        if (matchesA.Count > 0)
        {
            SetAnswer(matchesA,replaced,question,item);
        }
        else
        {
            replaced.Answer = question.Answer;
        }

        if (!hasNull)
        {
            if (matchesA.Count == 0 && matchesQ.Count == 0)
            {
                completed = new QACompleted();    <- this object
                MapEmpty(replaced,completed, question.Id);

            }
            else
            {
                completed = new QACompleted();  <- this object
                MapCompleted(replaced, completed, question.Id, item);
            }


            goodResults.Add(completed);
        }
        else
        {
            uncompleted = new QAUncompleted();     <- this object
            MapUncompleted(replaced,uncompleted,item, question.Id);

            badResults.Add(uncompleted);
        }
    }
    var success = InsertIntoDataBase(goodResults, "QACompleted");
    var success1 = InsertIntoDataBase(badResults, "QAUncompleted");
}

I have marked the objects. Should I just call them like replaced = NULL, or should i use the constructor ? What would be the difference between new QAText() and = null ?

Answer 1

Instantiating new (albeit empty) object always takes some memory, as it has to allocate space for the object's fields. If you aren't going to access or set any data in the instance, I see no point in creating it.

Answer 2

It's unfortunate that the code example is not written better. There seem to be lots of declarations left out, and undocumented side-effects in the code. This makes it very hard to offer specific advice.

That said…

Your replaced object does not appear to be retained beyond one iteration of the loop, so it's not part of the problem. The completed and uncompleted objects are added to lists, so they do add to your memory consumption. Likewise the goodResults and badResults lists themselves (where are the declarations for those?).

If you are using a computer with too little RAM, then yes...you'll run into performance issues as Windows uses the disk to make up for the lack of RAM. And even with enough RAM, at some point you could run into .NET's limitations with respect to object size (ie you can only put so many elements into a list). So one way or the other, you seem to need to reduce your peak memory usage.

You stated that when the data in the lists is inserted into the database, the lists are cleared. So presumably that means that there are so many elements in the values list (one of the undeclared, undocumented variables in your code example) that the lists and their objects get too large before getting to the end of the inner loop and inserting the data into the database.

In that case, then it seems likely the simplest way to address the issue is to submit the updates in batches inside the inner foreach loop. Eg at the end of that loop, add something like this:

if (goodResults.Count >= 100000)
{
    var success = InsertIntoDataBase(goodResults, "QACompleted");
}

if (badResults.Count >= 100000)
{
    var success = InsertIntoDataBase(badResults, "QACompleted");
}

(Declaring the actual cut-off as a named constant of course, and handling the database insert result return value as appropriate).

Of course, you would still do the insert at the end of the outer loop too.

Answer 3

The memory cost of creating objects

Creating objects in C# will always have a memory cost. This relates to the memory layout of object. Assuming you are using 64 bit OS, the runtime has to allocate an extra 8 bytes for sync block, and 8 bytes for method table pointer. After the sync block and method table pointer are your customized data fields. Besides the inevitable 16 bytes header, objects are always aligned to the boundary of 8 bytes and therefore can incur extra overhead.

You can roughly estimate the memory overhead if you know exactly what is the number of objects you create. However I would suggest you be careful when assuming that your memory pressure is coming from object layout overhead. This is also the reason I suggest you estimate the overhead as the first step. You might end up realizing that even if the layout overhead can magically be completely removed, you are not going to make a huge difference in terms of memory performance. After all, for a million objects, the overhead of object header is only 16 MB.

The difference between replaced = new QAText() and replaced = null

I suppose after you set replaced to null you still have to create another QAText()? If so, memory-wise there is no real difference to the garbage collector. The old QAText instance will be collected either way if you are not making any other reference to it. When to collect the instance, however, is the call of garbage collector. Doing replaced = null will not make the GC happen earlier.

You can try to reuse the same QAText instance instead of creating a new one every time. But creating a new one every time will not result in high memory pressure. It will make the GC a little busier therefore result in a higher CPU usage.

Identify the real cause for high memory usage

If your application is really using a lot of memory, you have to look at the design of your QACompleted and QAUncompleted objects. Those are the objects added to the list and occupy memory until you submit them to the database. If those objects are designed well(they are only taking the memory they have to take), as Peter pointed out you should use a smaller batch size so you don't have to keep too many of them in memory.

There are other factors in your program that can possible cause unexpected memory usage. What is the data structure for goodResults and badResults? Are they List or LinkedList? List internally is nothing but a dynamic array. It uses a grow policy which will always double its size when it is full. The always-double policy can eat up memory quickly especially when you have a lot of entries.

LinkedList, on the other side, does not suffer from the above-mentioned problem. But every single node requires roughly 40 extra bytes.

It also worth-checking what MapCompleted and MapUnCompleted methods are doing. Are they making long-lived reference to replaced object? If so it will cause a memory leak.

As a summary, when dealing with memory problems, you should focus on macro-scope issues such as the choice of data structures, or memory leaks. Or optimize your algorithms so that you don't have to keep all the data in memory all the time.