The collective agreements in Sweden are pretty much a win-win between workers and employers. It is something that most of the industry and the unions care about. Basically, the government has left to the industry and unions to agree on a lot of stuff that is decided by law in other countries. E.g. Sweden does not have a minimum wage. This system has led to much fewer costly conflicts and strikes compared to many other countries for almost a century.
I really love this era of sci-fi, a kind of short window between the immature boy fantasies before and the dull hard SF the came after. The weirdness, the hallucinatory, the craziness! And most importantly, so many great writers.
Doesn't Hard SF both predate and postdate New Wave? It's a thread that weaves through the whole of science-fiction. (heck - didn't Jules Verne once diss H.G. Wells for not being "hard sci-fi enough"?)
To be fair to the crowd that came after, the average consumption of creativity-enhancing substances was a lot less in the 80's and forward than in the [60's, early 80's] period.
If you're seeking weirdness and hallucinatory craziness, I think Peter Watts, Tamsyn Muir, and Charles Stross (among many others) can absolutely deliver.
Another fun offshoot combining New Wave and Cyberpunk is Transrealism. Rudy Rucker has a way with illustrating immense mathematical ideas while keeping the zany hippie dreams alive.
Others have in reply. See mocking bird, almost all are influenced by state.
The other factor is corporate influence. Most of the media is owned by the add dollars that drive it, so it's not the truth, often its what helps or at least doesn't harm the Corp that passes the filters.
30+ years later Tcl/Tk is still in active use. In space industry (maybe more on the old side of the old/new space dichotomy) it is used everyday to command and control satellites (both simulators and flatsats on ground and actual satellites in space).
(Sorry for hijacking the thread with a general fuzz question.)
I want to do fuzz testing on a library/framework written in C++. The actual target to test against is a simulator that takes input from a socket according to a network protocol. This simulator is built on both Linux and Windows.
What fuzzing frameworks would you recommend for this? There are quite a few and not always easy for me (as a fuzzing beginner) to understand the differences between them. Some of them seems to be abandoned projects as well.
Can you elaborate a bit regarding the -mflat compiler option? Why does it improve timing jitter etc? I am not sure I understand the description from the GCC docs. Is it disabling the register windows? Isn't that one of the big selling points of the SPARC architecture?
There is a finite number of register windows, usually 8 but only 7 can be used because the 8th serves as "sentinel" to detect over- and underflow.
Once register windows are full (a function call wants to activate the next register window but there is no unused window left) window overflow occurs and a trap handler is activated.
The trap handler "unwinds" the register windows and stores all the contents in memory (stack). Now the next function can continue with an empty set of register windows. Once you return from the function, the contents of the windows have to be restored (window underflow trap).
Problem is that the trap handlers can't know which of the registers in each window were in use. Therefore all have to be saved/restored. This ratio will worsen when you write smaller functions that use less register and nest deeper.
So there are two issues: 1. You can't really know at which point in your program that underflow/overflow occurs because it changes depending on the exact path of execution through the program. 2. Unnecessary memory write/read operations. While ca. 120 x 32-bit words is not that much, with an 8-bit wide SRAM, some waitstates and EDAC this might be noticeable. (Consider that the LEON processors have a data cache for read access but for writing only a "store buffer" that queues few memory writes)
Using -mflat every register is saved by the caller/callee (as ABI demands) on the stack. This means that the memory accesses are predictable and spread out over each function call.
So, my personal conclusion is that register windows are an intriguing idea on the surface but become useless when you aren't writing 80s spaghetti code. There were many similar ideas at that time, e.g., Am29000.
We’d considered using mflat, but we’re not that performance constrained (and prefer the slightly smaller binary size with register windows enabled). I may do some profiling of the under flow/overflow interrupts though since you’ve now got me second guessing myself.
Registers asr22/23 contain a cycle counter that you can use to time stuff. If it's not present, there's a register in the DSU that counts cycles but that requires an access via the AHB bus. You can measure a lot of things with those cycle counters, like context switch and interrupt handling times, memcpy vs naive for-loop, linear vs. binary search on small arrays...
I'd expect a few microseconds per overflow at most but it depends a lot on the characteristics of the system. Of course, if the application is not sensitive to a few microseconds here and a few microseconds there that optimization might not be worth it.
You don't normally use public key encryption in satellites, it is some sort of block crypto. CCSDS (a bunch of standards for space applications that is quite popular in the industry) recommends AES-HMAC for authentication and AES-GCM for both authentication and encryption.
My experience with a LEON processor ~100 MHz is that it is hard to get much throughput out of an AES implementation.
