This really depends on the nature of the binary data, and the constraints that “text” places on your output. First off, if your binary data is not compressed, try compressing before encoding. We can then assume that the distribution of 1/0 or individual bytes is more or less random. Now: why do you need text? … Read more
Here’s a slightly neater (IMO) short but complete program to demonstrate the same thing: using System; class Test { const int Size = 100000; static void Main() { object[] array = new object[Size]; long initialMemory = GC.GetTotalMemory(true); for (int i = 0; i < Size; i++) { array[i] = new string[0]; } long finalMemory = … Read more
One way to examine this is to look at the code in WinDbg. So given the code below, let’s see how that appears on the heap. var numbers = new Int32[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; The first thing to do is to locate the instance. As I … Read more
Personally I’d go with the option of not using placement new on the array and instead use placement new on each item in the array individually. For example: int main(int argc, char* argv[]) { const int NUMELEMENTS=20; char *pBuffer = new char[NUMELEMENTS*sizeof(A)]; A *pA = (A*)pBuffer; for(int i = 0; i < NUMELEMENTS; ++i) { … Read more
I know you’re asking about performance overhead, but you really should not use try/catch and if interchangeably. try/catch is for things that go wrong that are outside of your control and not in the normal program flow. For example, trying to write to a file and the file system is full? That situation should typically … Read more
There is a cost associated with exception handling on some platforms and with some compilers. Namely, Visual Studio, when building a 32-bit target, will register a handler in every function that has local variables with non-trivial destructor. Basically, it sets up a try/finally handler. The other technique, employed by gcc and Visual Studio targeting 64-bits, … Read more
On most architectures, the cost consists of saving all (or some, or none) of the registers to the stack, pushing the function arguments to the stack (or putting them in registers), incrementing the stack pointer and jumping to the beginning of the new code. Then when the function is done, you have to restore the … Read more
Take a look at the java API, and you’ll see many classes and interfaces with the same name in different packages. For example: java.lang.reflect.Array java.sql.Array So, if you import java.lang.reflect.* and java.sql.* you’ll have a collision on the Array type, and have to fully qualify them in your code. Importing specific classes instead will save … Read more
It appears that the overhead is temporary diskspace that the database used to run some of the queries, so you should only worry if this gets really high. You can compare ‘Optimizing the table’ with the defragmenting of your hard drive. I quote: Every database will, over time, require some form of maintenance to keep … Read more
Order of magnitude: zero. In other words, you won’t see your throughput cut in half, or anything like it, when you add TLS. Answers to the “duplicate” question focus heavily on application performance, and how that compares to SSL overhead. This question specifically excludes application processing, and seeks to compare non-SSL to SSL only. While … Read more