|
What would you suggest to do?
TOMZ_KV
|
|
|
|
|
Sprinkle WAITFOR DELAY '00:00:01' (or a more appropriate value, do a performance analysis first; it should run faster than the old unoptimized version) judiciously across your newly optimized SPs, so you still have room for improvement.
|
|
|
|
|
How can you be sure that both procedures are doing the same? I mean in all cases, not just on a few test cases.
|
|
|
|
|
The old one had been in production for a long while. Users knew that it returned correct results but just took too much time to run. They got timeout messages from time to time. Instead of fixing it, it was easier and quicker to write a new one.
TOMZ_KV
|
|
|
|
|
Just came across that code comment above a function. Not sure what it means. Maybe they got fed up and decided that they were finished working (though the task itself was incomplete)? Or maybe the code is complete, but never got put to use?
|
|
|
|
|
Gryphons Are Awesome! Gryphons Are Awesome!
|
|
|
|
|
Or does it refer only to the comment which is technically finished but proper explanation isn't implemented
|
|
|
|
|
I suspect the code worked and they ended up doing something else. I would have commented out the function as well if that were the case.
<sig notetoself="think of a better signature">
<first>Jim
<last willyoudomyhomeworkforme="false">Meadors
|
|
|
|
|
1. May be the poor soul was forced to do VB and was just frustrated.
2. Coding finished. Comments never implemented.
3. Finished may be an event and the handler was never implemented.
4. It's a clue to treasure. Could be anagram. I can think of mine, eleventh and prism as the words.
5. May be it's Dave showing off his CCC skills.
"Bastards encourage idiots to use Oracle Forms, Web Forms, Access and a number of other dinky web publishing tolls.", Mycroft Holmes[ ^]
|
|
|
|
|
C++ code.
This is either brilliant, or just bloody awful. I'm coming down on the side of "bloody awful":
recv in the curr structure below is declared as:
BYTE recv[64];
DWORD verb;
...
verb = (upper[curr->recv[0]] << 24) + (upper[curr->recv[1]] << 16) + (upper[curr->recv[2]] << 8) + 0x20;
switch (verb)
{
case 'CMD ':
...
break;
case 'MON ':
...
break;
case 'END ':
...
break;
case 'EXT ':
...
break;
default:
...
break;
}
WE ARE DYSLEXIC OF BORG. Refutance is systile. Your a$$ will be laminated.
There are 10 kinds of people in the world: People who know binary and people who don't.
|
|
|
|
|
Gryphons Are Awesome! Gryphons Are Awesome!
|
|
|
|
|
I guess this was used to circumvent the restriction that a switch statement can't be used on unmanaged strings.
|
|
|
|
|
A very smart way of circumventing the restrictions of C--!
|
|
|
|
|
I did similar in C about twenty years ago, but I could only fit two characters into a character literal.
If you'll pardon my rusty C:
char* s ;
// read a line from a file into s
short* i = s ;
switch ( *i ) ...
This enabled me to easily parse some reports. I wish I still had the code.
|
|
|
|
|
PIEBALDconsult wrote: I did similar in C about twenty years ago, but I could only fit two characters into a character literal.
If you'll pardon my rusty C:
char* s ;
// read a line from a file into s
short* i = s ;
switch ( *i ) ...
On most hardware platforms, this will cause some alignment indigestion for every second pair of chars. Assigning a short off of an even byte boundary will usually cause a lot of work for the processor, perhaps involving exceptions and retries.
I like the thinking though...
--
Harvey
|
|
|
|
|
I only did it with the first two characters per line.
|
|
|
|
|
For a string, that could still be at an odd address.
--
Harvey
|
|
|
|
|
It's ugly, yes.
But it also has the potential to be fast. By loading the three characters and one space into a machine word, it is a single machine instruction to compare each value, and if the compiler spots that - and it damn well should - then it can use a machine-word look up table and index into a machine-word jump table. And you can't get much faster than that!
If this is in time-critical code, then it could be justified. Provided it was well commented. If it's in user input handling, then the author needs to meet Mr Firing Squad for being too "clever".
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
|
|
|
|
|
It's in a thread where it's listening for something from a TCPIP connection (sort of a command channel). It's low-volume, and as such, I don't think the "cleverness" is warranted. And no, it's not commented at all.
It's not that I don't understand what he was doing. I just think he was being too clever for his own good. And in the (unlikely?) event that the code is ever ported to a big-endian system, it would be completely broken.
WE ARE DYSLEXIC OF BORG. Refutance is systile. Your a$$ will be laminated.
There are 10 kinds of people in the world: People who know binary and people who don't.
|
|
|
|
|
Perhaps not a meeting with Mr Firing Squad than, but a meeting with Mr Big Stick seems warranted.
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
|
|
|
|
|
I don't think it would, as it's doing the + and shift manually. If it was just switch(recv[0]) then it would be endian vulnerable.
In the absence of language or framework features that allow you to switch on a string, I have no problem with this.
|
|
|
|
|
You've missed the point ... all multibyte char literals are endian-sensitive.
To make it endian-insensitive, it should be
#define VB(a,b,c) (((((a)<<8)+(b))<<8)+(c))
verb = VB(upper[curr->recv[0]], upper[curr->recv[1]], upper[curr->recv[2]]);
switch (verb)
{
case VB('C','M','D'):
...
|
|
|
|
|
Oh really? So in that case doing switch(*recv) should be safe.
|
|
|
|
|
I have no idea which of the things I wrote are the subject of your "oh really", but all of them are correct. As for the rest, it's a non sequitur. Both *recv and multi-char literals are endian-sensitive, so you appear to have committed a fallacy of affirmation of the consequent ... a rather basic failure of logic. But if you want to go around switching on 4-char literals thinking that it's portable, be my guest ... just don't do it in any code that might affect my life.
|
|
|
|
|
You can use big words all you like, but either 'CMD ' is endian sensitive, i.e. it is the byte stream 'C', 'M', 'D', ' ' on one system and ' ', 'D', 'M', 'C' on another, or it isn't, i.e. it's always 'C', 'M', 'D', ' ' and therefore maps to a different integer.
In the first case, *recv won't be correct because the byte stream you're checking for is always the same, but the code in the original example would be, because it manually makes the integer in the big-endian manner, and that will be the value that the constant has if it switches the byte order. And if not, *recv will be correct, even if the integer interpretation of that value will be different.
There is one good argument you could have deployed, which is that the standard doesn't actually define whether a multi character constant refers to byte order or integer value. But if it has a consistent meaning in real world compilers, that doesn't really matter.
|
|
|
|