1

I'm trying to optimize some code where I have a large number of arrays containing structs of different size, but based on the same interface. In certain cases the structs are larger and hold more data, othertimes they are small structs, and othertimes I would prefer to keep null as a value to save memory.

My first question is. Is it a good idea to do something like this? I've previously had an array of my full data struct, but when testing mixing it up I would virtually be able to save lots of memory. Are there any other downsides?

I've been trying out different things, and it seams to work quite well when making an array of a common interface, but I'm not sure I'm checking the size of the array correctly.

To simplified the example quite a bit. But here I'm adding different structs to an array. But I'm unable to determine the size using the traditional Marshal.SizeOf method. Would it be correct to simply iterate through the collection and count the sizeof for each value in the collection?

IComparable[] myCollection = new IComparable[1000];
myCollection[0] = null;
myCollection[1] = (int)1;
myCollection[2] = "helloo world";
myCollection[3] = long.MaxValue;

System.Runtime.InteropServices.Marshal.SizeOf(myCollection);

The last line will throw this exception:

Type 'System.IComparable[]' cannot be marshaled as an unmanaged structure; no meaningful size or offset can be computed.

Excuse the long post:

  1. Is this an optimal and usable solution?
  2. How can I determine the size of my array?
jsmars
  • 1,640
  • 5
  • 21
  • 33

2 Answers2

1

I may be wrong but it looks to me like your IComparable[] array is a managed array? If so then you can use this code to get the length

int arrayLength = myCollection.Length;

If you are doing platform interop between C# and C++ then the answer to your question headline "Can I find the length of an unmanaged array" is no, its not possible. Function signatures with arrays in C++/C tend to follow the following pattern

void doSomeWorkOnArrayUnmanaged(int * myUnmanagedArray, int length) 
{
    // Do work ...
}

In .NET the array itself is a type which has some basic information, such as its size, its runtime type etc... Therefore we can use this

void DoSomeWorkOnManagedArray(int [] myManagedArray) 
{
    int length = myManagedArray.Length; 
    // Do work ...
}

Whenever using platform invoke to interop between C# and C++ you will need to pass the length of the array to the receiving function, as well as pin the array (but that's a different topic).

Does this answer your question? If not, then please can you clarify

Dr. Andrew Burnett-Thompson
  • 20,980
  • 8
  • 88
  • 178
  • Thanks for the answer, sorry if the question was unclear. I was mainly wondering about the memory usage of such an array. I have a large number of arrays holding a lot of data, so I am trying to replace some entries with smaller optimized structs and in some cases null values to save physical memory. – jsmars Jan 12 '12 at 20:55
0

Optimality always depends on your requirements. If you really need to store many elements of different classes/structs, your solution is completely viable.

However, I guess your expectations on the data structure might be misleading: Array elements are per definition all of the same size. This is even true in your case: Your array doesn't store the elements themselves but references (pointers) to them. The elements are allocated somewhere on the VM heap. So your data structure actually goes like this: It is an array of 1000 pointers, each pointer pointing to some data. The size of each particular element may of course vary.

This leads to the next question: The size of your array. What are you intending to do with the size? Do you need to know how many bytes to allocate when you serialize your data to some persistent storage? This depends on the serialization format... Or do you need just a rough estimate on how much memory your structure is consuming? In the latter case you need to consider the array itself and the size of each particular element. The array which you gave in your example consumes approximately 1000 times the size of a reference (should be 4 bytes on a 32 bit machine and 8 bytes on a 64 bit machine). To compute the sizes of each element, you can indeed iterate over the array and sum up the size of the particular elements. Please be aware that this is only an estimate: The virtual machine adds some memory management overhead which is hard to determine exactly...

chris
  • 148
  • 6
  • Thanks! This answers my question. I was mainly wondering how the array was saved in the physical memory, since i have a lot of arrays and am trying to replace some entries with smaller structs. From what your saying I can calculate this from the size of the array * memory usage of a reference + memory size of the data when iterating through. Correct? – jsmars Jan 12 '12 at 20:59