sysinfo | Cross-platform library to fetch system information

Looking at the strace output for both root and greg, the problem seems clear.

For the root user, python 3.6 finds the libraries in /usr/lib64/python3.6.

However, for greg, it only looks under /usr/bin/python3 for subdirectories. That doesn't work because /usr/bin/python3 is a file.

I suspect that the user greg has PYTOHNHOME set erroneously to the location of the Python binary , and that is causing the issue.

Remove PYTOHNHOME from your environment, log out and log in again.

Note: the stuff below is probably barking up the wrong tree. I'll leave it for information.

The encodings module is an (undocumented) part of the python standard library. It is used by the locale module.

Based on the output I suspect that your Python installation has been damaged or corrupted. Try re-installing python.

EDIT:

If a forced re-install doesn't fix the problem, check that the directory encodings exist in your Python stdlib directory, and is accessible for all users.

To find out which directory that is:

TL;DR: Your map update works fine. The message is a bug in bpftool.

Bpftool updates the maps just as you would expect; and then, after processing all the batch file, it checks errno. If errno is 0, it supposes that everything went fine, and it's good. If not, it prints strerror(errno) so you can see what went wrong when processing the file.

errno being set is not due to your map updates. I'm not entirely sure of what's happening to it. The bug was seemingly introduced with commit cf9bf714523d ("tools: bpftool: Allow unprivileged users to probe features"), where we manipulate process capabilities with libcap. Having a call to cap_get_proc() in feature.c is apparently enough for the executable to pick it up and to run some checks on capabilities that are supported, or not, on the system even if we're not doing any probing. I'm observing the following calls with strace:

To simplify script1 a bit, you can try using the WinNT names and skip searching AD:

You should check for errors instead of ignoring them. If you replace get_process("Opera").ok(); with get_process("Opera").unwrap();, you should see an error message complaining that your program couldn't open file process_list.txt for writing.

This is because you try to open the file twice: the first time in let _log = … then again when calling write("process_list.txt", …). But the second time fails because the file is still open from the first time.

You should either get rid of the _log variable since you don't use it, or use _log.write (…)?; to write to the file.

sysinfo is just thin system call wrapper and async-signal-safe:

You're doing integer division here:

First note that sysinfo will actually already give you the size in kB (KiloBytes). That means that you actually divide by 1000.0 to get GB (GigaByte). Also I think you would want your output to be double precision.

I modified your code

TL;DR: you are measuring time in the wrong way. Use clock_gettime(CLOCK_MONOTONIC, ...) instead of clock().

You are measuring time using clock(), which as stated on the manual page:

[...] returns an approximation of processor time used by the program. [...] The value returned is the CPU time used so far as a clock_t

The system clock used by clock() measures CPU time, which is the time spent by the calling process while using the CPU. The CPU time used by a process is the sum of the CPU time used by all of its threads, but not its children, since those are different processes. See also: What specifically are wall-clock-time, user-cpu-time, and system-cpu-time in UNIX?

Therefore, the following happens in your 3 scenarios:

1. No parallelism, sequential code. The CPU time spent running the process is pretty much all there is to measure, and will be very similar to the actual wall-clock time spent. Note that CPU time of a single threaded program is always lower or equal than its wall-clock time.

2. Multiple child processes. Since you are creating child processes to do the actual work on behalf of the main (parent) process, the parent will use almost zero CPU time: the only thing that it has to do is a few syscalls to create the children and then a few syscalls to wait for them to exit. Most of its time is spent sleeping waiting for the children, not running on the CPU. The children processes are the one that run on the CPU, but you are not measuring their time at all. Therefore you end up with a very short time (1ms). You are basically not measuring anything at all here.

3. Multiple threads. Since you are creating N threads to do the work, and taking the CPU time in the main thread only, the CPU time of your process will account to the sum of CPU times of the threads. It should come to no surprise that if you are doing the exact same calculation, the average CPU time spent by each thread is T/NTHREADS, and summing them up will give you T/NTHREADS * NTHREADS = T. Indeed you are using roughly the same CPU time as the first scenario, only with a little bit of overhead for creating and managing the threads.

All of this can be solved in two ways:

1. Carefully account for CPU time in the correct way in each thread/process and then proceed to sum or average the values as needed.
2. Simply measure wall-clock time (i.e. real human time) instead of CPU time using clock_gettime with one of CLOCK_REALTIME, CLOCK_MONOTONIC or CLOCK_MONOTONIC_RAW. Refer to the manual page for more info.

if you use \\?\ prefix in unicode path - the long paths is always supported in any version of windows (even win2000 and xp). question about support long paths - only affect another path types, which not begin with \\?\, such as c:\*

from Maximum Path Length Limitation

The Windows API has many functions that also have Unicode versions to permit an extended-length path for a maximum total path length of 32,767 characters. ... To specify an extended-length path, use the "\\?\" prefix. For example, "\\?\D:\very long path".

usual on any individual function documentation direct stated about \\?\ prefix too (if it supported by this api - File I/O functions always support this prefix, when shell api - never)

for instance from GetFileAttributesW

To extend this limit to 32,767 wide characters, call the Unicode version of the function (GetFileAttributesW), and prepend "\\?\" to the path.

the same on CreateFileW and so on..

To extend this limit to 32,767 wide characters, use this Unicode version of the function and prepend "\\?\" to the path.