Large Object within Pointer to Function & Switch

[Bryan Parkoff]

Do you know that current C++ Compiler limits to 64KB segments in source
code? It is good news that Microsoft Visual C++ 2005 has expanded to 4GB
segments in source code. 4GB segment is ideal for large object using
pointer to function and switch. Please list other C++ Compilers if they
have added a support of 4GB segments.
I am able to write 65,536 functions and 65,536 function's memory address
is stored into pointer to function list. It takes about 256KB. The test
has shown that each function out of 65,536 functions have been executed
successfully with correct result in both debug version and release version.
Switch can contain 65,536 cases in debug version, but C++ Compiler takes
more time to compile than pointer to function. Unfortunately, it will not
compile in release version. Unknown error is not found in any
documentation. (Not important to discuss this issue.)
I think that it is best practice to write small functions through
pointer to function list rather than large switch in one big function. By
the way, small functions can fit in cache. (Correct?).
If you are going to write 1 to 268,435,456 functions, memory address in
pointer to function list will take up to 1GB.
I know what you are going to say -- laugh -- can't be done. I urge you
to try if you are willing to write complex project. Think about holographic
character like Star Trek or character for game what you want to write. This
big object contains body including head, arm, leg, and everything. You need
to write hundred or thousand functions to respond moving arm, leg, and head.
More functions to be responded for mouth talking.
It makes 32-bit CPU machine to be slower to manipulate C++ Compiler for
large object so 64 bit CPU machine may be working with large RAM.

Please tell me what you think the best practice. Live with big object
by adding /bigobj and /Gy to Microsoft C++ Compiler. Check option
documentation for other C++ Compilers. Should write large pointer to
function list in more than 1 million line of source code? Or...Split half
or quarter function to pointer list into two or four module source code?

Please refer me to other newsgroups when I am interested to work large
object using optimization and performance using C++ Compiler's option, but
not through Microsoft alone. Please advise.

Bryan Parkoff

[BobR]

Bryan Parkoff wrote in message ...

Huh?

http://www.parashift.com/c++-faq-lite/how-to-post.html

[Steve Pope]

Bryan Parkoff <no****@nospam. comreplies to my post,

>How are you guys defining "segment"?

>Steve,

Sorry. My mistake. I refer section (not segment). Look
this article below.

Microsoft Article: [snip]

Thanks, that's very interesting. Apparently it's some limitation
on resolving function calls in the linker.

(I wouldn't think it'd be too much trouble for an implementation
to remove this limit entirely, but I've seen stranger limitations.)

Steve

[Bryan Parkoff]

"BobR" <Re***********@ worldnet.att.ne twrote in message
news:cb******** *************@b gtnsc05-news.ops.worldn et.att.net...

>
Bryan Parkoff wrote in message ...

Huh?

http://www.parashift.com/c++-faq-lite/how-to-post.html

Well,

I did follow guideline, but I ask people to rephrase their opinion. My
question is -- is it best practice to write 64K functions or more into
pointer to function list? Is it best to create small or big function? It
is simple question. It seems that none wish to answer this question. They
may feel sorry when they face problem near the future so they will ask the
same question since in the past.
I have researched to get more information how C++ Compiler can handle
the limitation for general OS, but none implement to provide good
documentation nor FAQs. I do see when they claim to be 1,024 maximum for
functions. However you should be able to exceed limit and perform test to
prove that it is working perfectly. Didn't you?

Bryan Parkoff

[Kirit Sælensminde]

Bryan Parkoff wrote:

"BobR" <Re***********@ worldnet.att.ne twrote in message
news:cb******** *************@b gtnsc05-news.ops.worldn et.att.net...

Bryan Parkoff wrote in message ...

Huh?

http://www.parashift.com/c++-faq-lite/how-to-post.html

Well,

I did follow guideline, but I ask people to rephrase their opinion. My
question is -- is it best practice to write 64K functions or more into
pointer to function list? Is it best to create small or big function? It
is simple question. It seems that none wish to answer this question. They
may feel sorry when they face problem near the future so they will ask the
same question since in the past.
I have researched to get more information how C++ Compiler can handle
the limitation for general OS, but none implement to provide good
documentation nor FAQs. I do see when they claim to be 1,024 maximum for
functions. However you should be able to exceed limit and perform test to
prove that it is working perfectly. Didn't you?

Maybe it's because we don't understand the question. I'm certainly
finding it difficult to understand.

Are you asking about objects as instances of classes or objects as in
object files, the results of compilation? The subject line seems to
imply the first, the content the second.

Why would you want a switch statement that had 65,535 cases in it? Why
would you want to write your own message dispatcher like this?

When you say "64K functions" your talking about the number of
functions? I find it hard to imagine that anybody would write that many
functions even on a huge system and expect them all to be called
through a single switch statement. If you find that you want to do this
then I suspect you'd be better off thinking about redesigning your
solution rather than worrying about compiler limits.

Function size is a tricky one. Functions should be the right size, and
normally the right size is small, but of course there are many
exceptions and edge cases where to split a function just becomes
arbitrary. Personally I always go for the easiest to maintain size, and
not worry too much about how the compiler will aggregate
up/inline/unroll functions unless I've proven that there isn't a better
algorithm I can use to speed things up. Finding a better method
generally gives much better performance boosts than worrying unduly
about function versus cache sizes.
K

[BobR]

Bryan Parkoff wrote in message ...

>
"BobR" wrote in message...

>Huh?
http://www.parashift.com/c++-faq-lite/how-to-post.html

Well,

I did follow guideline, but I ask people to rephrase their opinion. My
question is -- is it best practice to write 64K functions or more into
pointer to function list?

Several years ago I read a recommended paper on Unix programming. It stated
at one point "programs should do only one thing, but, do that one thing very
well". If you have hit a limit, you need to split up the task. Even the most
'function intensive' programs I've seen on GNU/Linux did not come close to
64k functions. Heck, If you look at the Linux kernel, with *everything*
turned on, it does not come close to that limit.

Is it best to create small or big function?

I came up to C++ from Assembler, so, naturally I've taken a look at the
assembler output stage of GCC. I noticed that the usual habit (necessity)
when entering a function is to do a 'pusha'(push all, x86). I thought, "that
seems excessive, in Assembler I only push-pop when and what I need". If I
*only* looked at that I would say, always put as much in one function as you
can.
But, C++ is a much stranger animal. The general advice is - do not
pre-optimise, just write clean, clear code. Then, if there is a problem with
speed, profile the program, identify the bottlenecks and only work on those
areas.

So what do I do? If I see a section of code that gets used many times, it
goes in a function(usuall y a member of a class). You should make a function
do one thing (and do it well), big or small is not the target.

It is simple question. It seems that none wish to answer this question.

You do have answers from others.

They may feel sorry when they face problem near the future so they will ask

the

>same question since in the past.

You may have problems if you spend all your time worrying about some limit,
instead of studying good design.

I have researched to get more information how C++ Compiler can handle
the limitation for general OS, but none implement to provide good
documentatio n nor FAQs.

Sounds like a personal problem, I've never seen any of the experts in these
NGs whine about some limit. (and some of them work on HUGE projects.)

I do see when they claim to be 1,024 maximum for
functions. However you should be able to exceed limit and perform test to
prove that it is working perfectly. Didn't you?

If *your* compiler can't do what you want, get a better one. www.gnu.org

MinGW (GNU compiler): http://www.mingw.org/ (windows)

Dev-C++ IDE: http://www.bloodshed.net/ (with MinGW, easy install)
MinGWStudio http://www.parinyasoft.com/
--
Bob R
POVrookie