The Wiert Corner – irregular stream of stuff

Jeroen W. Pluimers on .NET, C#, Delphi, databases, and personal interests

  • My badges

  • Twitter Updates

    • @EefvanKoos Dank je wel. Stapje voor stapje kom ik er wel. 1 hour ago
    • @EefvanKoos Heb een arts die al heel lang goede resultaten aflevert. Duimen dat het bij mij ook goed gaat. 1 hour ago
    • RT @trouw: PvdA-Kamerlid Henk Nijboer stapt per direct uit het presidium, het voorzittend orgaan van de Tweede Kamer. Hij zegt dat de kriti… 1 hour ago
    • RT @locuta: Energieprijsplafond ziet er goed uit. 1,45€ per m3 gas en 0,40€ per kWh. Met limieten van respectievelijk 1200m3 gas en 2900kWh… 1 hour ago
    • RT @DeSpeld: Grootayatollah Khamenei in coma geslagen omdat hij zijn tulband draagt als een slet… 1 hour ago
  • My Flickr Stream

  • Pages

  • All categories

  • Enter your email address to subscribe to this blog and receive notifications of new posts by email.

    Join 2,914 other followers

Archive for January 26th, 2022

In life, including working life “slow is smooth, and smooth is fast.”

Posted by jpluimers on 2022/01/26

I’ve been agile all my (not just programming) life, and only figured out this century that there is a vocabulary for that, containing the words agile, extreme programming, feature-driven and many more.

Now with the passing of the years, I also realise I have been trying to do “slow and smooth” all my life, and that with age (and less adrenaline) this becomes easier and easier.

I think “slow and smooth” goes well with “agile”, specially when you keep the focus on “doing things right” (and trying to do them right the first time, and keeping it right in incremental steps).

It often reminds me of the Dutch phrase “heeft u haast, gaat dan zitten” which often is attributed to be part of the many Chinese proverbs. It roughly translates to “when in a hurry, take a seat”, and suggests to take a step back and think when under pressure. Maybe this English version of a Chinese proverb comes close: “When you are in a hurry, the horse holds back”.

For is it is intriguing that mainly Chinese, but in a broader sense Asian, proverbs play such an important role, whereas Western proverbs get less and less important. Informal knowledge seems to diminish in Western culture, which I think is a pity.

Maybe all these vocabulary things that started  to make sense way after my puberty also have to do with being diagnosed autistic at 50. That too started a lot of puzzle-pieces to suddenly make sense.

Below the links that inspired me to make this blog post in the first place:


Read the rest of this entry »

Posted in Agile, Conference Topics, Conferences, Development, Event, LifeHacker, Power User, Software Development | Leave a Comment »

ESXi: reloading all virtual machines from their (potentially) vmx files

Posted by jpluimers on 2022/01/26

I had to reload all registered virtual machine configurations after replacing an NVMe adapter in one of my ESXi hosts (see the posts next week).

The below script is based on this series of April last year on listing, stopping, starting, hibernating and waking up VMs, especially

  1. VMware ESXi console: viewing all VMs, suspending and waking them up: part 1 on Busybox, sed and regular expressions (especially capture groups)
  2. VMware ESXi console: viewing all VMs, suspending and waking them up: part 2 on vim-cmd vmsvc commands, especially the on the ones accepting a vmid parameter
  3. VMware ESXi console: viewing all VMs, suspending and waking them up: part 3 digging deeper into the various vim-cmd vmsvc/power.* commands
  4. VMware ESXi console: viewing all VMs, suspending and waking them up: part 4 on amending vim-cmd vmsvc/getallvms with information from vim-cmd vmsvc/power.getstate and vim-cmd vmsvc/get.config
  5. VMware ESXi console: viewing all VMs, suspending and waking them up: part 5 on applying the various vim-cmd vmsvc/power.* commands on a list of relevant virtual machines

Here is the script

vmids=`vim-cmd vmsvc/getallvms | sed -n -E -e "s/^([[:digit:]]+)\s+((\S.+\S)?)\s+(\[\S+\])\s+(.+\.vmx)\s+(\S+)\s+(vmx-[[:digit:]]+)\s*?((\S.+)?)$/\1/p"`
for vmid in ${vmids} ; do                                       
    powerState=`vim-cmd vmsvc/power.getstate ${vmid} | sed '1d'`                                                                                    
    name=`vim-cmd vmsvc/get.config ${vmid} | sed -n -E -e '/\(vim.vm.ConfigInfo\) \{/,/files = \(vim.vm.FileInfo\) \{/ s/^ +name = "(.*)",.*?/\1/p'`                         
    vmPathName=`vim-cmd vmsvc/get.config ${vmid} | sed -n -E -e '/files = \(vim.vm.FileInfo\) \{/,/tools = \(vim.vm.ToolsConfigInfo\) \{/ s/^ +vmPathName = "(.*)",.*?/\1/p'`
    echo "Reloading vmx of VM with id ${vmid} which has power state ${powerState} (name = ${name}; vmPathName = ${vmPathName})."
    vim-cmd vmsvc/reload ${vmid}
exit 0

Note that the script can throw errors, for instance the below one:

# vim-cmd vmsvc/reload 27
(vmodl.fault.SystemError) {
   faultCause = (vmodl.MethodFault) null, 
   faultMessage = , 
   reason = "Invalid fault"
   msg = "Received SOAP response fault from []: reload

This particular error means that the ESXi system itself is in an invalid state (as opposed to the virtual machine being an invalid state). In this case, it can be thrown if the ESXi system is in Maintenance Mode: in that case, it is not allowed to reload any .vmx virtual machine configurations (it only shows the configuration at the time that hostd got started).

There are two ways to solve this:

  1. The blunt way: restart the hostd as this will re-read the .vmx files
  2. The not so blunt way: bring the server out of maintenance mode, then rerun the vim-cmd vmsvc/reload command.

On the many places that can throw vim.fault.InvalidState

In this case, the reason for vim.fault.InvalidState was that the server was in maintenance mode. However, be aware that there are way more places that can throw vim.fault.InvalidState.

Via [Wayback/] 1-day-SAP-custom/InvalidState.rst at master · bcstryker/1-day-SAP-custom and [Wayback/] bcstryker/1-day-SAP-custom, I found [Wayback/] InvalidState – vSphere Web Services API – VMware {code} that lists about 200 API calls for this seemingly simple fault:

Fault Description

An InvalidState fault is thrown if the operation failed due to the current state of the system.

For example, at [Wayback] Failed to deploy VM: vim.fault.InvalidState – VMware Technology Network VMTN the cause of vim.fault.InvalidState was deploying an .ova file over a slow WiFi connection.

On VMware services and their names

The VMware service names are very well explained in the [Wayback] what is difference between hostd, Vpxa and vpxd. – VMware Technology Network VMTN answer by [Wayback] About AndreTheGiant – VMware Technology Network VMTN

  • hostd is the daemon for direct VIC connection (when you use VIC to connect to your ESX).
  • vpx is the original name of vCenter Center, so:
    • vpxa is the VC agent (ESX side)
    • vpxd is the VC daemon (VC side)

Since ESXi 5.0, the VIC (VMware Infrastructure Client) got gradually replaced by the vSphere Web Client which is serviced by the hostd as well, see:


Posted in ESXi6, ESXi6.5, ESXi6.7, ESXi7, Power User, Virtualization, VMware, VMware ESXi | 1 Comment »

When floating point code suddenly becomes orders magnitudes slower (via C++ – Why does changing 0.1f to 0 slow down performance by 10x? – Stack Overflow)

Posted by jpluimers on 2022/01/26

When working with converging algorithms, sometimes floating code can become very slow. That is: orders of magnitude slower than you would expect.

A very interesting answer to [Wayback] c++ – Why does changing 0.1f to 0 slow down performance by 10x? – Stack Overflow.

I’ve only quoted a few bits, read the full question and answer for more background information.

Welcome to the world of denormalized floating-point! They can wreak havoc on performance!!!

Denormal (or subnormal) numbers are kind of a hack to get some extra values very close to zero out of the floating point representation. Operations on denormalized floating-point can be tens to hundreds of times slower than on normalized floating-point. This is because many processors can’t handle them directly and must trap and resolve them using microcode.

If you print out the numbers after 10,000 iterations, you will see that they have converged to different values depending on whether 0 or 0.1 is used.

Basically, the convergence uses some values closer to zero than a normal floating point representation dan store, so a trick is used called “denormal numbers or denormalized numbers (now often called subnormal numbers)” as described in Denormal number – Wikipedia:

In a normal floating-point value, there are no leading zeros in the significand; rather, leading zeros are removed by adjusting the exponent (for example, the number 0.0123 would be written as 1.23 × 10−2). Denormal numbers are numbers where this representation would result in an exponent that is below the smallest representable exponent (the exponent usually having a limited range). Such numbers are represented using leading zeros in the significand.

Since a denormal number is a boundary case, many processors do not optimise for this.


Posted in .NET, Algorithms, ARM, Assembly Language, C, C#, C++, Delphi, Development, Software Development, x64, x86 | Leave a Comment »

%d bloggers like this: