Rather than IPV6 globally and IPV4 internally, I think IPV6 should be what the countries that attack us, who just happen to have very large populations, can use for themselves. Do you have any idea how many IP address ranges we are attacked from in places like Latvia? Let them do their attacking with IPV6. Good riddance.
You ARE a troll - or maybe just an uneducated idiot.
Latvia? It is a small country of 2 million people, smaller than many cities in the US. They are member of the European Union and NATO. Are you suggesting that the US should copy Iran and segregate itself from the Internet? If even EU and NATO are labelled as "countries that attack us" what is left?
Then we could additionally agree that 0.x.x.x.x would be somehow bridged to the respective address in IPv4 world. However you couldn't access the higher hosts from IPv4 without moving to the new addressing scheme.
That is what they did. Except instead of adding "0." you need to add "::ffff:" in front like this::ffff:x.x.x.x
This wont give you access to IPv4 hosts though. Because when you think about it, you might realise that IP packets come with a source and a destination address. How are you going to fix the extended address in the source field? Without a valid source address the destination host can not reply.
Even though that 99% would be fine with a/60 there simply is no reason not to give them all a/48. The extra bits are being wasted anyway so why not let people play with it? Plus the ISP will not have to deal with corporate and private customers having different prefix sizes - one size fits all is going to save them bucks in management.
IPv6-addresses can actually be much easier to remember than IPv4. Why? Because there is a system to it.
Here in the RIPE region there is only three possible prefixes for any address: 2001::, 2003:: and 2a0x::
In practice you are only working with one or a few ISPs. This means the first two blocks are always going to be the same. My ISP has 2001:1448::.
We got a/48. We happens to be number 201. So our addresses are all starting with 2001:1448:201::.
Everything from that point on is something I decided. If I want easy to remember addresses I would choose easy to remember addresses. My primary server could be 2001:1448:201::1. I would remember it as the::1 server.
It is true that if you let your hosts autoconfigure to a random interface identifier that will be impossible to remember. But there is nothing stopping you from using manually configuration or DHCPv6 to number your hosts in a human friendly manner.
It is still single-manned, but now it has active control, the pilot is lying down, the capsule looks like a downsized Apollo capsule and it has a launch escape system.
The rocket was also changed from a solid hybrid to fluid fuelled (LOX+alcohol).
Last month they launched a two stage rocket. The official plan is for a suborbital flight but they are getting close to hardware that could do orbital.
Comparing this to Apollo is silly and I think it was only meant to illustrate the basic shape of the capsule.
The government of the USA could not afford to redo Apollo. Yet it is fascinating what these guys are managing to do in their spare time. Even if it is nothing like the pride of USA.
It is not some official prefix. Anyone can run a NAT64 server. In this case it is some university in Lithuania that has a public accessible NAT64 server with the prefix 2001:778:0:ffff:64::/96.
Using a public NAT64 is fine for testing but you should not use it for your production setup. However setting up your own is trivial.
If the slashdot team thinks it is too hard or too much work or their hosting provider does not support IPv6, they could install NAT64 on a server somewhere and put the NAT64 address as a AAAA on slashdot.org. For now one server would definitely be adequate for the expected IPv6 traffic.
I'm not quite sure what happens for internal traffic if you have multiple routers on a single subnet. Maybe you'll end up sending packets to whichever one responds to NDP first?
No this is well defined. Your computer will record all the NDP replies and put them in a list. It will then pick the first one in the list and stay with that one until it fails. If it fails it will move to the next entry in the list.
IPv6 has active monitoring of peers. If 30 seconds passes without any inbound traffic from the selected peer it will send three probes. If the probes goes unanswered the peer has failed and your computer goes to the next entry in the list.
This means having multiple routers "just works". With IPv4 having more than one router requires advanced setup of the routers and basic home routers simply can't do it. With IPv6 you just connect multiple routers and its done. Your computer will select one of them. If your current selected router fails, your computer will move on to the other within approximately 30 seconds. It even works if the two routers are from different ISPs.
2) While wind doesn't track consumption requirements, solar generally does pretty well. Inter-seasonal variations are handled by geographic and generation-mix diversity.
This depends on your location. For Denmark wind actually tracks consumption very well. The country uses much more electricity during the cold winter months compared to summer. And wind produces more during winter as well. If the country were to build 100% wind about 70% of the power would be produced when needed.
3. Currently, Germany is in a "20% scenario". We already have the highest electricity prices in the world (for a major country) ~26 âct/kWh and the import/export saldo in the area of 15% of total production. The electricity prices will likely increase by another 3-4 cents next year and so far there's no end to the price hike in sight.
Germany might be a horrible example as the political system there seems to insist making bad choices while shutting down the nuclear powerplants.
Look at your northern neighbours instead: Denmark. In the year 2011 the electricity used in Denmark was 28% wind and 11% other renewable energy (solar, biomass, imported hydroelectric power from Sweden and Norway, etc). 41% of electricity produced in Denmark was from renewable sources while only 39% electricity used was from renewable sources. This is because Denmark will sell a lot of wind generated power to neighbours (eg. Norway) and later buy some of it back from the big hydroelectric dams in Norway.
In year 2020 Denmark will have 78% of the used electric power from renewable sources. 48% will be from wind.
There is no "battery" as such needed. Not even pumped storage. The trick is to use wind and solar when available. And power from the dams and bio when there is a lack of wind and solar.
You just need to configure your network with DHCPv6 instead of autoconf. Or use static configuration. Then you are free to name your stuff prefix::1,::2,::3 and so on. Or any other scheme.
The IP address of your gateway is always fe80::%eth0. Like this:
~$ ping6 -c1 fe80::%eth0 PING fe80::%eth0(fe80::) 56 data bytes 64 bytes from fe80::216:3eff:fe36:5f25: icmp_seq=1 ttl=64 time=0.798 ms
--- fe80::%eth0 ping statistics --- 1 packets transmitted, 1 received, 0% packet loss, time 0ms rtt min/avg/max/mdev = 0.798/0.798/0.798/0.000 ms
(slightly different syntax on windows)
Not that hard eh?
And nothing stops you from assigning easy to remember addresses to your stuff. In fact since you have little to no constraints, you can make up schemes to your liking. Your webserver could be 2001:db8:531::1. Your decide the::1 part. You quickly learn that first three parts as it never changes it is "you". The prefix is also usually not any longer than a IPv4 address.
Feel free to try to implement a malloc that uses a copying garbage collector. Maybe you should take the Computer Science 101 first to learn what it is though. Or try wikipedia.
To not leave you completely in the dark I will give you a hint: A copying garbage collector will regularly move memory around (copy it). This means the pointers change. You might make a malloc that returns a pointer to some memory allocated by the copying GC, but at some unknown point in the future this pointer will become invalid because the GC decided to move the memory. To fix this, the GC needs to scan the stack and change all references from old pointer to new pointer. And THAT is what you can not implement in straight C because you have no control over the stack in C. You also need a way to flush all register allocated variables onto the stack so they can be scanned. You could easily enough change the pointers if you just knew what data on the stack is a pointer and what is not. However there is no way to tell the difference between a random integer and a pointer on the stack.
A copying GC is a common memory allocation strategy for a lot of computer language implementations. I used it as an example of something that would be very hard to implement in C to illustrate that C is not assembler.
The so called zero-cost exception handling is a tradeoff. It is only zero cost when no exceptions are thrown. The actual exception handling is more expensive than a setjmp/longjmp strategy.
However remember that C++ requires that you run all the destructors during unwinding. You will probably not be able to simply skip through a ton of stack for this reason. Other languages without destructors (most garbage collected languages) can have greater gain from using longjmp.
Oh really? So its arrived in function X (say strlen()) and its made a pre compiled map of every possible variation of the stack that could exist having arrived at that function including recursion? Function return addresses, parameter values, automatics values?
There are no variations. There is only one copy of the code for strlen in memory. And only one copy of the code that called strlen. That is what we are looking up.
Say the code for your calling function located starting at address X and continues until address Y. And lets assume strlen is going to throw an exception. Since the throw command is in strlen it knows all about the strlen stack layout. It will find the return address Z from the stack. If it was your function that invoked strlen that address Z will be between X and Y. Using a binary search (*) for Z in the static table, the throw code will find the address of the exception handler for your function. It will then unroll the stack back to the state of calling, then jump to the exception handler.
We are now in the exception handler of your function. Your exception handler knows the size of the stack for your function. If the exception is not handled, it repeat the process by unrolling your part of the stack, lookup the return address to find the next exception handler and so on.
Recursion, varargs and what have we is not a problem. It is all handled just like a normal function return, except instead of jumping back to the original calling point we jump to a exception handler.
(*) as an alternative to a binary search it is also possible to store the address of every single function invocation within your code. In this case you can use a hash table lookup instead. This method also enables the compiler to have special handling for each and every invocation point if needed.
You seriously think C++ exceptions are zero cost?? The compiler saving the stack for you at a "try" instead of you having to explicitly call setjmp will make no difference to overall performance.
I do not know how major C++ compilers do it (*). I personally made a Standard ML compiler that implemented zero-cost exceptions handling. The compiler will NOT save the stack at a try, it does not need to. Instead the compiler will generate a static map of the stack. At the "throw" point the code will check the return address on the stack. You then take this address and make a lookup in a table that maps the address space for all functions, this tells you what function called you. Then you lookup the static stack map for that function, which tells how to unwind the stack correctly.
There are plenty of papers on the subject. Look it up, you might learn something.
Templates carry no run-time overhead, unlike the C# and Java generics, etc. That's why template-driven programming produces such fast code.
I do not know about C# but Java generics use type erasure, meaning the specific type does not exist in the compiled byte code at all. There is no overhead. All generics does is ensuring your code is correct at compile time.
C++ templates is something completely different. It is both more and less than generics depending on how you view it.
Nothing is impossible to emulate, it is a turing complete language.
But the problem is probably harder than you realise. For example the C compiler can chose to store a pointer in registers and it can optimize variables away entirely. For this reason I do not think your option c) is really possible, not without assuming an awful lot of things about the C compiler.
My point was that you can not write C that will do such thing the same way as a program written in assembly. And you can not write a C program that emulates it in a "natural" way. Compilers can generate code that no human would ever want to write manually.
Gambit actually has a hybrid system that uses reference counting to solve the problem. It does not scan the C stack and can therefore not move objects still referenced from the C stack.
You will often see comments to the effect that C is like assembler or that you can do anything in C it just lacks some syntactic sugar. But that is very wrong. Yes, you can to some degree emulate object oriented programming in C. But how would you go about changing your memory allocation (malloc) to use a copying garbage collector? Or do lazy evaluation Haskell style? How do you implement zero-cost exception handling? (longjmp is NOT zero-cost because it requires setjmp).
These concepts are easy for a compiler that compiles directly to assembly language. Often less mature compilers will compile to C as an intermediate language, but in that case the compiler will not be able to generate the most efficient code. For example, a compiler that uses C as intermediate step can implement exceptions using setjmp/longjmp but this adds extra code at every function call. A compiler that goes directly to assembler can implement exception unrolling using static knowledge about the stack instead for a so called zero-cost exception handling solution.
Similarly, a compiler using C as intermediate will be forced to use a conservative garbage collector such as the Boehm GC. Using more efficient solutions such as a copying garbage collector is simply not possible without knowledge of the stack layout.
Let me simply quote a few things for you on that page.
"::1/128 — The loopback address is a unicast localhost address. If an application in a host sends packets to this address, the IPv6 stack will loop these packets back on the same virtual interface (corresponding to 127.0.0.0/8 in IPv4)."
So 127.0.0.1 should become::1.
Alternatively, if you do not want to actually use it for anything, it could be converted into the prefix:
"::ffff:0:0/96 — This prefix designated an IPv4-mapped IPv6 address. "
Instead it was translated into this:
"The 96-bit zero-value prefix::/96, originally known as IPv4-compatible addresses, was mentioned in 1995[38] but first described in 1998.[44] This class of addresses was used to represent IPv4 addresses within an IPv6 transition technology. Such an IPv6 address has its first (most significant) 96 bits set to zero, while its last 32 bits are the IPv4 address that is represented. In February 2006, the Internet Engineering Task Force (IETF) has deprecated the use of IPv4-compatible addresses."
4) NAT66 is more complicated without providing anything that is not already there with solution 1. The better question is why bother? And I think most people wont which means it will be rare. Which again means software will not be expecting it.
With IPv4 NAT is so prevalent that all software knows how to do NAT traversal. With IPv6 NAT will be so rare that most software will not be implementing NAT traversal. For sure no software currently has that feature for IPv6. Things like STUN is not even defined for IPv6.
NAT66 might have specialized uses. I am not arguing that it should not exist. I am only arguing that it will be uncommon and that if you are considering it, you might want to ask the experts for other solutions before you go ahead. There might be something really simple, like the fact that they buildin automatic failover into the protocol itself. A fact few people know.
The buildin automatic failover works like this:
Your computer monitors traffic to the router. If 30 seconds has passed without receiving anything from the router, the computer will probe the router three times (ping it) with 1 second delay between probes. If probing fails the computer will look for another router. The computer will use the prefix associated with the chosen router, so switching router also means using the other prefix. Active TCP connections can not survive this but the NAT66 solution has the same problem.
The router also monitors upstream the same way. If upstream stops responding the router will withdraw the prefix from the network. This will in turn cause all computers to go look for another router.
This makes pseudo-multihoming with IPv6 so easy that anyone can do it. My mother could do it. There is absolutely no configuration required. You do not even need to enable it somewhere or buy some special router. Just order from two different ISPs, connect the routers and you are flying. It might not be perfect but it will work for most people.
For more advanced setups I am betting on LISP. This will be true multihoming with load-balancing. LISP is what will bring multihoming to everyone. I agree that BGP is too expensive and too hard.
1) Order internet from two different ISPs. Get a router from each. Connect both routers to your internal network. Done.
Yes for most people and small business nothing more is required. What will happen is that every computer will get two IP-addresses, one from each ISP. As part of IPv6 every computer monitors the routers and automatically chooses one that is responsive. If you unplug a router every computer will start using the other with a failover time of maximum 30 seconds.
This option does not provide backup if you want to host a web server. But it will work with a mail server because SMTP allows you to simply publish both IP-addresses. Many private persons and small business have no need for a local server so this could be a good and easy solution.
2) Get your own/48 address range from your RIR and get service from two different ISPs. Use BGP to advertise your range. This is exactly the same way as you do dual homing with IPv4.
3) Use LISP. This is not quite ready for primetime yet, but I think it will be there in about a year. It is backed by Cisco et al. http://www.lisp4.net/
LISP is the most interesting option. You get your own/48 just like the BGP option, but LISP allows you to split that up into as many units you want. You can use some of it at the office and give each employee a/64 for their home office. There are no scalability problems.
4*) Other home-made solutions. Some people will try to sell you a NAT66 based solution. Just say no. You could also build a primitive LISP like solution yourself by using a tunnel to a server somewhere.
That thing is broken. Even the default values is transformed wrong. It transforms 127.0.0.1 to 0::7f00:1 but the correct answer is::1. Then it transforms::1 to 0.0.0.1. And 0.0.0.1 becomes 2002::1 (WTF?).
What good is it if does not know about the special cases?
Slashdot Mirror
Rather than IPV6 globally and IPV4 internally, I think IPV6 should be what the countries that attack us, who just happen to have very large populations, can use for themselves. Do you have any idea how many IP address ranges we are attacked from in places like Latvia? Let them do their attacking with IPV6. Good riddance.
You ARE a troll - or maybe just an uneducated idiot.
Latvia? It is a small country of 2 million people, smaller than many cities in the US. They are member of the European Union and NATO. Are you suggesting that the US should copy Iran and segregate itself from the Internet? If even EU and NATO are labelled as "countries that attack us" what is left?
Then we could additionally agree that 0.x.x.x.x would be somehow bridged to the respective address in IPv4 world. However you couldn't access the higher hosts from IPv4 without moving to the new addressing scheme.
That is what they did. Except instead of adding "0." you need to add "::ffff:" in front like this ::ffff:x.x.x.x
This wont give you access to IPv4 hosts though. Because when you think about it, you might realise that IP packets come with a source and a destination address. How are you going to fix the extended address in the source field? Without a valid source address the destination host can not reply.
/60 is actually 16 subnets.
Even though that 99% would be fine with a /60 there simply is no reason not to give them all a /48. The extra bits are being wasted anyway so why not let people play with it? Plus the ISP will not have to deal with corporate and private customers having different prefix sizes - one size fits all is going to save them bucks in management.
IPv6-addresses can actually be much easier to remember than IPv4. Why? Because there is a system to it.
Here in the RIPE region there is only three possible prefixes for any address: 2001::, 2003:: and 2a0x::
In practice you are only working with one or a few ISPs. This means the first two blocks are always going to be the same. My ISP has 2001:1448::.
We got a /48. We happens to be number 201. So our addresses are all starting with 2001:1448:201::.
Everything from that point on is something I decided. If I want easy to remember addresses I would choose easy to remember addresses. My primary server could be 2001:1448:201::1. I would remember it as the ::1 server.
It is true that if you let your hosts autoconfigure to a random interface identifier that will be impossible to remember. But there is nothing stopping you from using manually configuration or DHCPv6 to number your hosts in a human friendly manner.
It is still single-manned, but now it has active control, the pilot is lying down, the capsule looks like a downsized Apollo capsule and it has a launch escape system.
The rocket was also changed from a solid hybrid to fluid fuelled (LOX+alcohol).
Last month they launched a two stage rocket. The official plan is for a suborbital flight but they are getting close to hardware that could do orbital.
Comparing this to Apollo is silly and I think it was only meant to illustrate the basic shape of the capsule.
The government of the USA could not afford to redo Apollo. Yet it is fascinating what these guys are managing to do in their spare time. Even if it is nothing like the pride of USA.
You will find it here: http://ipv6.lt/nat64_en.php
It is not some official prefix. Anyone can run a NAT64 server. In this case it is some university in Lithuania that has a public accessible NAT64 server with the prefix 2001:778:0:ffff:64::/96.
Using a public NAT64 is fine for testing but you should not use it for your production setup. However setting up your own is trivial.
If the slashdot team thinks it is too hard or too much work or their hosting provider does not support IPv6, they could install NAT64 on a server somewhere and put the NAT64 address as a AAAA on slashdot.org. For now one server would definitely be adequate for the expected IPv6 traffic.
I'm not quite sure what happens for internal traffic if you have multiple routers on a single subnet. Maybe you'll end up sending packets to whichever one responds to NDP first?
No this is well defined. Your computer will record all the NDP replies and put them in a list. It will then pick the first one in the list and stay with that one until it fails. If it fails it will move to the next entry in the list.
IPv6 has active monitoring of peers. If 30 seconds passes without any inbound traffic from the selected peer it will send three probes. If the probes goes unanswered the peer has failed and your computer goes to the next entry in the list.
This means having multiple routers "just works". With IPv4 having more than one router requires advanced setup of the routers and basic home routers simply can't do it. With IPv6 you just connect multiple routers and its done. Your computer will select one of them. If your current selected router fails, your computer will move on to the other within approximately 30 seconds. It even works if the two routers are from different ISPs.
2) While wind doesn't track consumption requirements, solar generally does pretty well. Inter-seasonal variations are handled by geographic and generation-mix diversity.
This depends on your location. For Denmark wind actually tracks consumption very well. The country uses much more electricity during the cold winter months compared to summer. And wind produces more during winter as well. If the country were to build 100% wind about 70% of the power would be produced when needed.
3. Currently, Germany is in a "20% scenario". We already have the highest electricity prices in the world (for a major country) ~26 âct/kWh and the import/export saldo in the area of 15% of total production. The electricity prices will likely increase by another 3-4 cents next year and so far there's no end to the price hike in sight.
Germany might be a horrible example as the political system there seems to insist making bad choices while shutting down the nuclear powerplants.
Look at your northern neighbours instead: Denmark. In the year 2011 the electricity used in Denmark was 28% wind and 11% other renewable energy (solar, biomass, imported hydroelectric power from Sweden and Norway, etc). 41% of electricity produced in Denmark was from renewable sources while only 39% electricity used was from renewable sources. This is because Denmark will sell a lot of wind generated power to neighbours (eg. Norway) and later buy some of it back from the big hydroelectric dams in Norway.
In year 2020 Denmark will have 78% of the used electric power from renewable sources. 48% will be from wind.
There is no "battery" as such needed. Not even pumped storage. The trick is to use wind and solar when available. And power from the dams and bio when there is a lack of wind and solar.
You just need to enter this into your /etc/hosts file:
2001:778:0:ffff:64::216.34.181.48 slashdot.org
Then slashdot.org is IPv6 enabled:
baldur@neaira:~$ curl -v -s http://slashdot.org/ | head ...
* About to connect() to slashdot.org port 80 (#0)
* Trying 2001:778:0:ffff:64:0:d822:b530... connected
> GET / HTTP/1.1
> User-Agent: curl/7.22.0 (x86_64-pc-linux-gnu) libcurl/7.22.0 OpenSSL/1.0.1 zlib/1.2.3.4 libidn/1.23 librtmp/2.3
> Host: slashdot.org
> Accept: */*
>
http://slashdot.org/slashdot.xrds
Content-Type: text/html; charset=utf-8
Content-Length: 100410
Date: Fri, 03 Aug 2012 02:52:51 GMT
X-Varnish: 830176495 830176249
Age: 15
Connection: keep-alive
You just need to configure your network with DHCPv6 instead of autoconf. Or use static configuration. Then you are free to name your stuff prefix::1, ::2, ::3 and so on. Or any other scheme.
The IP address of your gateway is always fe80::%eth0. Like this:
~$ ping6 -c1 fe80::%eth0
PING fe80::%eth0(fe80::) 56 data bytes
64 bytes from fe80::216:3eff:fe36:5f25: icmp_seq=1 ttl=64 time=0.798 ms
--- fe80::%eth0 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.798/0.798/0.798/0.000 ms
(slightly different syntax on windows)
Not that hard eh?
And nothing stops you from assigning easy to remember addresses to your stuff. In fact since you have little to no constraints, you can make up schemes to your liking. Your webserver could be 2001:db8:531::1. Your decide the ::1 part. You quickly learn that first three parts as it never changes it is "you". The prefix is also usually not any longer than a IPv4 address.
Feel free to try to implement a malloc that uses a copying garbage collector. Maybe you should take the Computer Science 101 first to learn what it is though. Or try wikipedia.
To not leave you completely in the dark I will give you a hint: A copying garbage collector will regularly move memory around (copy it). This means the pointers change. You might make a malloc that returns a pointer to some memory allocated by the copying GC, but at some unknown point in the future this pointer will become invalid because the GC decided to move the memory. To fix this, the GC needs to scan the stack and change all references from old pointer to new pointer. And THAT is what you can not implement in straight C because you have no control over the stack in C. You also need a way to flush all register allocated variables onto the stack so they can be scanned. You could easily enough change the pointers if you just knew what data on the stack is a pointer and what is not. However there is no way to tell the difference between a random integer and a pointer on the stack.
A copying GC is a common memory allocation strategy for a lot of computer language implementations. I used it as an example of something that would be very hard to implement in C to illustrate that C is not assembler.
The so called zero-cost exception handling is a tradeoff. It is only zero cost when no exceptions are thrown. The actual exception handling is more expensive than a setjmp/longjmp strategy.
However remember that C++ requires that you run all the destructors during unwinding. You will probably not be able to simply skip through a ton of stack for this reason. Other languages without destructors (most garbage collected languages) can have greater gain from using longjmp.
Oh really? So its arrived in function X (say strlen()) and its made a pre compiled map of every possible variation of the stack that could exist having arrived at that function including recursion? Function return addresses, parameter values, automatics values?
There are no variations. There is only one copy of the code for strlen in memory. And only one copy of the code that called strlen. That is what we are looking up.
Say the code for your calling function located starting at address X and continues until address Y. And lets assume strlen is going to throw an exception. Since the throw command is in strlen it knows all about the strlen stack layout. It will find the return address Z from the stack. If it was your function that invoked strlen that address Z will be between X and Y. Using a binary search (*) for Z in the static table, the throw code will find the address of the exception handler for your function. It will then unroll the stack back to the state of calling, then jump to the exception handler.
We are now in the exception handler of your function. Your exception handler knows the size of the stack for your function. If the exception is not handled, it repeat the process by unrolling your part of the stack, lookup the return address to find the next exception handler and so on.
Recursion, varargs and what have we is not a problem. It is all handled just like a normal function return, except instead of jumping back to the original calling point we jump to a exception handler.
(*) as an alternative to a binary search it is also possible to store the address of every single function invocation within your code. In this case you can use a hash table lookup instead. This method also enables the compiler to have special handling for each and every invocation point if needed.
You seriously think C++ exceptions are zero cost?? The compiler saving the stack for you at a "try" instead of you having to explicitly call setjmp will make no difference to overall performance.
I do not know how major C++ compilers do it (*). I personally made a Standard ML compiler that implemented zero-cost exceptions handling. The compiler will NOT save the stack at a try, it does not need to. Instead the compiler will generate a static map of the stack. At the "throw" point the code will check the return address on the stack. You then take this address and make a lookup in a table that maps the address space for all functions, this tells you what function called you. Then you lookup the static stack map for that function, which tells how to unwind the stack correctly.
There are plenty of papers on the subject. Look it up, you might learn something.
(*) A quick google search shows that GCC does indeed use zero-cost exceptions: http://stackoverflow.com/questions/691168/how-much-footprint-does-c-exception-handling-add
Templates carry no run-time overhead, unlike the C# and Java generics, etc. That's why template-driven programming produces such fast code.
I do not know about C# but Java generics use type erasure, meaning the specific type does not exist in the compiled byte code at all. There is no overhead. All generics does is ensuring your code is correct at compile time.
C++ templates is something completely different. It is both more and less than generics depending on how you view it.
Nothing is impossible to emulate, it is a turing complete language.
But the problem is probably harder than you realise. For example the C compiler can chose to store a pointer in registers and it can optimize variables away entirely. For this reason I do not think your option c) is really possible, not without assuming an awful lot of things about the C compiler.
My point was that you can not write C that will do such thing the same way as a program written in assembly. And you can not write a C program that emulates it in a "natural" way. Compilers can generate code that no human would ever want to write manually.
Gambit actually has a hybrid system that uses reference counting to solve the problem. It does not scan the C stack and can therefore not move objects still referenced from the C stack.
You will often see comments to the effect that C is like assembler or that you can do anything in C it just lacks some syntactic sugar. But that is very wrong. Yes, you can to some degree emulate object oriented programming in C. But how would you go about changing your memory allocation (malloc) to use a copying garbage collector? Or do lazy evaluation Haskell style? How do you implement zero-cost exception handling? (longjmp is NOT zero-cost because it requires setjmp).
These concepts are easy for a compiler that compiles directly to assembly language. Often less mature compilers will compile to C as an intermediate language, but in that case the compiler will not be able to generate the most efficient code. For example, a compiler that uses C as intermediate step can implement exceptions using setjmp/longjmp but this adds extra code at every function call. A compiler that goes directly to assembler can implement exception unrolling using static knowledge about the stack instead for a so called zero-cost exception handling solution.
Similarly, a compiler using C as intermediate will be forced to use a conservative garbage collector such as the Boehm GC. Using more efficient solutions such as a copying garbage collector is simply not possible without knowledge of the stack layout.
You sir needs to read up a little on the subject: http://en.wikipedia.org/wiki/IPv6_address
Let me simply quote a few things for you on that page.
"::1/128 — The loopback address is a unicast localhost address. If an application in a host sends packets to this address, the IPv6 stack will loop these packets back on the same virtual interface (corresponding to 127.0.0.0/8 in IPv4)."
So 127.0.0.1 should become ::1.
Alternatively, if you do not want to actually use it for anything, it could be converted into the prefix:
"::ffff:0:0/96 — This prefix designated an IPv4-mapped IPv6 address. "
Instead it was translated into this:
"The 96-bit zero-value prefix ::/96, originally known as IPv4-compatible addresses, was mentioned in 1995[38] but first described in 1998.[44] This class of addresses was used to represent IPv4 addresses within an IPv6 transition technology. Such an IPv6 address has its first (most significant) 96 bits set to zero, while its last 32 bits are the IPv4 address that is represented. In February 2006, the Internet Engineering Task Force (IETF) has deprecated the use of IPv4-compatible addresses."
I did not ask for a 6to4 conversion but even if I did, it would be wrong: http://en.wikipedia.org/wiki/6to4
"For example the global IPv4 address 192.0.2.4 has the corresponding 6to4 prefix 2002:c000:0204::/48."
So 0.0.0.1 would be 6to4 translated into 2002:0:1:: but instead they made it 2002::1.
So in fact, everything that happens on that page is simply broken.
4) NAT66 is more complicated without providing anything that is not already there with solution 1. The better question is why bother? And I think most people wont which means it will be rare. Which again means software will not be expecting it.
With IPv4 NAT is so prevalent that all software knows how to do NAT traversal. With IPv6 NAT will be so rare that most software will not be implementing NAT traversal. For sure no software currently has that feature for IPv6. Things like STUN is not even defined for IPv6.
NAT66 might have specialized uses. I am not arguing that it should not exist. I am only arguing that it will be uncommon and that if you are considering it, you might want to ask the experts for other solutions before you go ahead. There might be something really simple, like the fact that they buildin automatic failover into the protocol itself. A fact few people know.
The buildin automatic failover works like this:
Your computer monitors traffic to the router. If 30 seconds has passed without receiving anything from the router, the computer will probe the router three times (ping it) with 1 second delay between probes. If probing fails the computer will look for another router. The computer will use the prefix associated with the chosen router, so switching router also means using the other prefix. Active TCP connections can not survive this but the NAT66 solution has the same problem.
The router also monitors upstream the same way. If upstream stops responding the router will withdraw the prefix from the network. This will in turn cause all computers to go look for another router.
This makes pseudo-multihoming with IPv6 so easy that anyone can do it. My mother could do it. There is absolutely no configuration required. You do not even need to enable it somewhere or buy some special router. Just order from two different ISPs, connect the routers and you are flying. It might not be perfect but it will work for most people.
For more advanced setups I am betting on LISP. This will be true multihoming with load-balancing. LISP is what will bring multihoming to everyone. I agree that BGP is too expensive and too hard.
1) has automated failover.
There are three options:
1) Order internet from two different ISPs. Get a router from each. Connect both routers to your internal network. Done.
Yes for most people and small business nothing more is required. What will happen is that every computer will get two IP-addresses, one from each ISP. As part of IPv6 every computer monitors the routers and automatically chooses one that is responsive. If you unplug a router every computer will start using the other with a failover time of maximum 30 seconds.
This option does not provide backup if you want to host a web server. But it will work with a mail server because SMTP allows you to simply publish both IP-addresses. Many private persons and small business have no need for a local server so this could be a good and easy solution.
2) Get your own /48 address range from your RIR and get service from two different ISPs. Use BGP to advertise your range. This is exactly the same way as you do dual homing with IPv4.
3) Use LISP. This is not quite ready for primetime yet, but I think it will be there in about a year. It is backed by Cisco et al. http://www.lisp4.net/
LISP is the most interesting option. You get your own /48 just like the BGP option, but LISP allows you to split that up into as many units you want. You can use some of it at the office and give each employee a /64 for their home office. There are no scalability problems.
4*) Other home-made solutions. Some people will try to sell you a NAT66 based solution. Just say no. You could also build a primitive LISP like solution yourself by using a tunnel to a server somewhere.
That thing is broken. Even the default values is transformed wrong. It transforms 127.0.0.1 to 0::7f00:1 but the correct answer is ::1. Then it transforms ::1 to 0.0.0.1. And 0.0.0.1 becomes 2002::1 (WTF?).
What good is it if does not know about the special cases?