The issue is not motion, the vestibular system cannot measure velocity, only linear acceleration and rotation. The only issue is while you are accelerating in a horizontal direction in VR, but you are not actually acccelerating (remember acceleration is absolute not relative). But I don't expect this will be much of an issue. We don't have a problem speeding up or slowing down on a treadmill.
The mention of DMA-BUF makes me suspect that it involves rendered video being copied from the GPU to the main RAM and back to the GPU, which wastes energy. Does someone have details about how the integration works?
It's the opposite. The point of using DMA-BUFs is that those are the handles which are passed around, and the data never leaves GPU memory. The handles can be directly accessed from EGL/Vulkan and used as render source/targets.
Do you maybe know, when frames rendered by GPU 1 (e.g. fast GPU) need to be sent to GPU 2 (e.g. slow GPU doing the compositing and outputting to the monitor), how does the data actually get transferred? I can imagine the following possibilities:
1) GPU 1 writes to CPU RAM, GPU 2 reads from CPU RAM
2) GPU 1 writes to GPU 2 RAM via PCI Express (DMA between devices)
3) GPU 2 reads from GPU 1 RAM via PCI Express (DMA between devices)
It's supposed to refer to an object that is in GPU RAM. You can map it to CPU RAM to access it, but obviously that is slow. The userspace function you normally want to call to do this is "gbm_bo_map".
In any case, if the program forks in order to exec, it shouldn't be using fork at all, but posix_spawn. Fork gets more expensive as the virtual memory of the process grows, since it needs to copy page tables. For very large process forking can be prohibitively expensive due to this. And posix_spawn does not have this problem.
Suppose the the period of lights is equal to the time expected to move from one light to the next, and each light is red/green for the same amount of time. You have a green wave if you pass the first light green and drive at the expected speed. But if you drive twice as fast, you reach the second light red instead of green. Now it would work if the period of lights was half the time expected to get from one light to the next, but why would that generally be the case?
Actually I think the opposite will usually hold: you will still have a green wave if you drive at the expected speed divided by an integer.
Each floating point value that is not a NaN represents a certain real number, -inf or +inf (this can be expressed in terms of the sign bit, exponent and mantissa). Knowing that, a == b when neither operand is a NaN is defined as equality of what they represent, in purely mathematical terms. Similar can be said for inequality operators.
Be aware that +0.0 and -0.0 are different floating point values but represent the same real number, so +0.0 == -0.0 follows.
People who say == means nothing for floating point and you always need epsilon checks are wrong, plain and simple. == is very well defined. Don't confuse the definition of floating point operations with common practices for using them effectively.
You can iterate through all non-NaN values and check that successive ones are indeed not equal:
#include <math.h>
#include <stdint.h>
#include <assert.h>
#include <stdio.h>
#include <inttypes.h>
int main()
{
float x = (float)-INFINITY;
uint64_t count = 1;
while (x != (float)INFINITY) {
float y = nextafterf(x, (float)INFINITY);
assert(y != x);
x = y;
++count;
}
printf("Found %" PRIu64 " floats.\n", count);
return 0;
}
$ gcc -std=c99 -O3 a.c -lm -o a
$ ./a
Found 4278190081 floats.
(a little bit harder for doubles)
Interestingly, this only finds one zero (-0.0), hence the assert doesn't actually fail around zero.
Each int also corresponds to a certain real number, but if you write "x*(1/x)==1" for integer x, you'll either
(a) get x casted to a float
(b) get `div` instead (like in Python 2) and obtain a false result
(c) get cursed out with a type error.
These three options are available because it's possible to determine whether a given real number is representable as an int or not. This is not possible with floats.
Programming languages aren't able to express arbitrary real numbers, so to "determine whether a given real number is representable as an int or not" is mostly meaningless in a programming language as opposed to a computer algebra system.
What you can do is:
- determine if a float is an integer (trunc(x) == x),
- convert a float to a certain integer type with some kind of rounding, or get an error if it's out of range (see my comment with double_to_uint64),
- convert a float to a certain integer type exactly, or get an error if it's not representable (e.g. by doing both of the above).
The basic reason that so many people fail to use floats correctly is that they act like operations on floats are equivalent to operations on the real numbers they represent, when in fact they are usually defined as the operation on real numbers rounded to a representable value.
You don't always need epsilon. I've written lots of floating point code that works well without epsilon checks. See my comment in this thread (double_to_uint64) how what the OP needs can be done correctly without an epsilon check.
This is not right. The current rounding mode is not guaranteed to apply to integer to floating point conversions. Quoting C99, section 6.3.1.4, paragraph 2:
"When a value of integer type is converted to a real floating type, if the value being converted can be represented exactly in the new type, it is unchanged. If the value being converted is in the range of values that can be represented but cannot be represented exactly, the result is either the nearest higher or nearest lower representable value, chosen in an implementation-defined manner. If the value being converted is outside the range of values that can be represented, the behavior is undefined."
See it says implementation-defined manner, not according to the current rounding mode.
If you need different rounding behavior, just change trunc() to round(), floor() or ceil(). Note that it is important that the result is produced by converting the rounded double (y) to an integer type, not the original value (x).
Explanation:
- we first round the value to an integer (but still a floating point value),
- we then check that this integer is in the valid range of the target integer type by comparing it with exact integer values (0 and 2^N),
- if the check passes, then converting this integer to the target integer type is safe, and if the check fails, then conversion is not possible.
Of course if you literally need to convert to "long" you have a problem because the width of "long" is not known, but that is a rather different concern. I argue types with unknown width like "long" should almost never be used anyway.
Why use a webapp AND a local native gateway instead of just a native app? If your goal is to just not open any native win32/cocoa/etc UIs for some reason, there are existing native torrent clients with web interfaces served over http and those have been available for like a decade plus.
Webapp + native gateway also means that the torrent traffic ends up being suspended/throttled if the tab isn't foregrounded or if you close it, something you wouldn't have to deal with if the native gateway was just a native torrent client. Chrome Apps had a background privileged context that could keep running even if no tabs were open (though Google naturally discouraged this unless the app needed it), something you can't really get with a PWA currently (though Service Workers come close if you keep the tab open, I think? Maybe?)
