I believe WiringPi, like other Pi specific GPIO libraries such as pigpio and libbcm2835, works by mmap()ing part of kernel space into user space using /dev/mem (or the more specific /dev/gpiomem; beware not to mess around casually particularly with the former or you could cause just about anything, including serious filesystem corruption, to occur). You can find an example of this technique on elinux.org if you are interested.

This provides access to hardware registers normally only accessible to the kernel. What you are asking for -- to set the value of eight arbitrary GPIOs in parallel -- would require hardware pathways and the SoC, being organized around a CPU with 1-4 cores, probably does not quite have this; manipulating each requires code to execute on a processor core and that happens one instruction at a time.

[See joan's answer for more details about this -- evidently you can set GPIO values as a whole via hardware, but I'll let this answer stand for the general outline].

However, very likely you could do this in few enough instructions that even on a single core Pi running at 700 Mhz, eight GPIOs could be set within a microsecond, which is pretty much but not quite literally instantaneous. If you have to do parallel busing at a higher frequency than that, again, a special hardware feature would be required to implement it and the Pi does not have an 8 pin parallel bus.

This is not to say that it is necessarily all that feasible to do it at anywhere close to that rate in practice, but you are free to experiment.

It does mean if all you want to do is set the value of 8 gpios more or less at the same time, just do it with 8 procedural calls in code [or in parallel using the library features mentioned by joan] and the time it takes them to execute is what it is, but it probably will not be anything relative to a human scale.

I believe WiringPi, like other Pi specific GPIO libraries such as pigpio and libbcm2835, works by mmap()ing part of kernel space into user space using /dev/mem (or the more specific /dev/gpiomem; beware not to mess around casually particularly with the former or you could cause just about anything, including serious filesystem corruption, to occur). You can find an example of this technique on elinux.org if you are interested.

This provides access to hardware registers normally only accessible to the kernel. What you are asking for -- to set the value of eight arbitrary GPIOs in parallel -- would require hardware pathways and the SoC, being organized around a CPU with 1-4 cores, may require code to manipulate each execute linearly on a processor core (one instruction at a time).

[See joan's answer for more details about this -- evidently you can set GPIO values as a whole via hardware, but I'll let this answer stand for the general outline].

Even if this were the case, very likely you could do it in few enough instructions that on a single core Pi running at 700 Mhz, eight GPIOs could be set within a microsecond, which is pretty much but not quite literally instantaneous. If you have to do parallel busing at a higher frequency than that, again, a special hardware feature would be required to implement it and the Pi does not have an 8 pin parallel bus.

It does mean if all you want to do is set the value of 8 gpios more or less at the same time, just do it with 8 procedural calls in code [or in parallel using the library features mentioned by joan] and the time it takes them to execute is what it is, but it probably will not be anything relative to a human scale.

I believe WiringPi, like other Pi specific GPIO libraries such as pigpio and libbcm2835, works by mmap()ing part of kernel space into user space using /dev/mem (or the more specific /dev/gpiomem; beware not to mess around casually particularly with the former or you could cause just about anything, including serious filesystem corruption, to occur). You can find an example of this technique on elinux.org if you are interested.

This provides access to hardware registers normally only accessible to the kernel. What you are asking for -- to set the value of eight arbitrary GPIOs in parallel -- would require hardware pathways and the SoC, being organized around a CPU with 1-4 cores, probably does not quite have this; manipulating each requires code to execute on a processor core and that happens one instruction at a time.

However, very likely you could do this in few enough instructions that even on a single core Pi running at 700 Mhz, eight GPIOs could be set within a microsecond, which is pretty much but not quite literally instantaneous. If you have to do parallel busing at a higher frequency than that, again, a special hardware feature would be required to implement it and the Pi does not have an 8 pin parallel bus.

This is not to say that it is necessarily all that feasible to do it at anywhere close to that rate in practice, but you are free to experiment.

It does mean if all you want to do is set the value of 8 gpios more or less at the same time, just do it with 8 procedural calls in code and the time it takes them to execute is what it is, but it probably will not be anything relative to a human scale.

I believe WiringPi, like other Pi specific GPIO libraries such as pigpio and libbcm2835, works by mmap()ing part of kernel space into user space using /dev/mem (or the more specific /dev/gpiomem; beware not to mess around casually particularly with the former or you could cause just about anything, including serious filesystem corruption, to occur). You can find an example of this technique on elinux.org if you are interested.

This provides access to hardware registers normally only accessible to the kernel. What you are asking for -- to set the value of eight arbitrary GPIOs in parallel -- would require hardware pathways and the SoC, being organized around a CPU with 1-4 cores, probably does not quite have this; manipulating each requires code to execute on a processor core and that happens one instruction at a time.

[See joan's answer for more details about this -- evidently you can set GPIO values as a whole via hardware, but I'll let this answer stand for the general outline].

However, very likely you could do this in few enough instructions that even on a single core Pi running at 700 Mhz, eight GPIOs could be set within a microsecond, which is pretty much but not quite literally instantaneous. If you have to do parallel busing at a higher frequency than that, again, a special hardware feature would be required to implement it and the Pi does not have an 8 pin parallel bus.

This is not to say that it is necessarily all that feasible to do it at anywhere close to that rate in practice, but you are free to experiment.

It does mean if all you want to do is set the value of 8 gpios more or less at the same time, just do it with 8 procedural calls in code [or in parallel using the library features mentioned by joan] and the time it takes them to execute is what it is, but it probably will not be anything relative to a human scale.