Add support for Production/Development environments

Description

Production: Cache will not be checked for updates (better performance)
Development: Cache will be checked for updates (better debugging experience)

Nice to have:

[ ] Static kernel method to clear the cache

Note
This should be implemented in Okapi/Code-Transformer first and then extended from if needed.

Not checking the Cache for production would be really appreciated. This is probably the thing holding us back using this library currently.

Hi @djschilling,
I'll make sure to implement it next, shouldn't be too hard. Performance optimizations are also the next thing on my list.

@WalterWoshid hey, any progress here?

Hi @djschilling,
sorry for the late response. I have implemented the feature and also adjusted the performance tests and the differences between "Cached Aspects" and "Not checking the cache for cached aspects" are so small that the tests show there is sometimes a positive and sometimes a negative difference (in terms of time and memory). I guess the cache checking mechanism is not very performance heavy as initially thought.
For example here are the results on my local machine (24 × 13th Gen Intel® Core™ i7-13700HX & NVIDIA GeForce RTX 4050 Laptop):
(The important benchmarks are table 4 (comparison between cached and not checking cached files)

Benchmarks
Table 1: Without Aspects vs With Aspects (1 aspect, 1 execution)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00005221 s | 0.04062700 s | +0.04057479 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.00304198 s | +0.00304103 s |
| Class Loading Time         | Time   |    0.00004697 s | 0.03741193 s | +0.03736496 s |
| Execution Time             | Time   |    0.00000215 s | 0.00016689 s | +0.00016475 s |
| From Start to End          | Memory |         0.00 MB |      7.79 MB |      +7.79 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      0.68 MB |      +0.68 MB |
| Class Loading Time         | Memory |         0.00 MB |      7.08 MB |      +7.08 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (1 aspect, 1 execution)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00005221 s |        0.00355911 s | +0.00350690 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.00313377 s | +0.00313282 s |
| Class Loading Time         | Time   |    0.00004697 s |        0.00027585 s | +0.00022888 s |
| Execution Time             | Time   |    0.00000215 s |        0.00014496 s | +0.00014281 s |
| From Start to End          | Memory |         0.00 MB |             0.84 MB |      +0.84 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             0.77 MB |      +0.77 MB |
| Class Loading Time         | Memory |         0.00 MB |             0.04 MB |      +0.04 MB |
| Execution Time             | Memory |         0.00 MB |             0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (1 aspect, 1 execution)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00005221 s |                           0.00356507 s | +0.00351286 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.00311494 s | +0.00311399 s |
| Class Loading Time         | Time   |    0.00004697 s |                           0.00029516 s | +0.00024819 s |
| Execution Time             | Time   |    0.00000215 s |                           0.00014901 s | +0.00014687 s |
| From Start to End          | Memory |         0.00 MB |                                0.84 MB |      +0.84 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                0.77 MB |      +0.77 MB |
| Class Loading Time         | Memory |         0.00 MB |                                0.04 MB |      +0.04 MB |
| Execution Time             | Memory |         0.00 MB |                                0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (1 aspect, 1 execution)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.00355911 s |                           0.00356507 s | +0.00000596 s |
| Boot Time - Kernel::init() | Time   |        0.00313377 s |                           0.00311494 s | -0.00001884 s |
| Class Loading Time         | Time   |        0.00027585 s |                           0.00029516 s | +0.00001931 s |
| Execution Time             | Time   |        0.00014496 s |                           0.00014901 s | +0.00000405 s |
| From Start to End          | Memory |             0.84 MB |                                0.84 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             0.77 MB |                                0.77 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.04 MB |                                0.04 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (5 aspects, 5 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00011420 s | 0.04512310 s | +0.04500890 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.00297284 s | +0.00297189 s |
| Class Loading Time         | Time   |    0.00010610 s | 0.04190397 s | +0.04179788 s |
| Execution Time             | Time   |    0.00000501 s | 0.00024199 s | +0.00023699 s |
| From Start to End          | Memory |         0.01 MB |      7.81 MB |      +7.80 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      0.75 MB |      +0.75 MB |
| Class Loading Time         | Memory |         0.01 MB |      7.03 MB |      +7.02 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (5 aspects, 5 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00011420 s |        0.00384784 s | +0.00373363 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.00332999 s | +0.00332904 s |
| Class Loading Time         | Time   |    0.00010610 s |        0.00028515 s | +0.00017905 s |
| Execution Time             | Time   |    0.00000501 s |        0.00022984 s | +0.00022483 s |
| From Start to End          | Memory |         0.01 MB |             0.86 MB |      +0.85 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             0.78 MB |      +0.78 MB |
| Class Loading Time         | Memory |         0.01 MB |             0.04 MB |      +0.04 MB |
| Execution Time             | Memory |         0.00 MB |             0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (5 aspects, 5 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00011420 s |                           0.00402808 s | +0.00391388 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.00348616 s | +0.00348520 s |
| Class Loading Time         | Time   |    0.00010610 s |                           0.00030398 s | +0.00019789 s |
| Execution Time             | Time   |    0.00000501 s |                           0.00023508 s | +0.00023007 s |
| From Start to End          | Memory |         0.01 MB |                                0.86 MB |      +0.85 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                0.78 MB |      +0.78 MB |
| Class Loading Time         | Memory |         0.01 MB |                                0.04 MB |      +0.04 MB |
| Execution Time             | Memory |         0.00 MB |                                0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (5 aspects, 5 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.00384784 s |                           0.00402808 s | +0.00018024 s |
| Boot Time - Kernel::init() | Time   |        0.00332999 s |                           0.00348616 s | +0.00015616 s |
| Class Loading Time         | Time   |        0.00028515 s |                           0.00030398 s | +0.00001884 s |
| Execution Time             | Time   |        0.00022984 s |                           0.00023508 s | +0.00000525 s |
| From Start to End          | Memory |             0.86 MB |                                0.86 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             0.78 MB |                                0.78 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.04 MB |                                0.04 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (20 aspects, 20 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00021887 s | 0.06894112 s | +0.06872225 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.00331187 s | +0.00331092 s |
| Class Loading Time         | Time   |    0.00020313 s | 0.06459379 s | +0.06439066 s |
| Execution Time             | Time   |    0.00001287 s | 0.00102901 s | +0.00101614 s |
| From Start to End          | Memory |         0.10 MB |      7.96 MB |      +7.86 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      0.81 MB |      +0.81 MB |
| Class Loading Time         | Memory |         0.09 MB |      7.06 MB |      +6.96 MB |
| Execution Time             | Memory |         0.00 MB |      0.09 MB |      +0.09 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (20 aspects, 20 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00021887 s |        0.00480914 s | +0.00459027 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.00340486 s | +0.00340390 s |
| Class Loading Time         | Time   |    0.00020313 s |        0.00032687 s | +0.00012374 s |
| Execution Time             | Time   |    0.00001287 s |        0.00107312 s | +0.00106025 s |
| From Start to End          | Memory |         0.10 MB |             0.92 MB |      +0.82 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             0.84 MB |      +0.84 MB |
| Class Loading Time         | Memory |         0.09 MB |             0.05 MB |      -0.05 MB |
| Execution Time             | Memory |         0.00 MB |             0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (20 aspects, 20 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00021887 s |                           0.00475597 s | +0.00453711 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.00340605 s | +0.00340509 s |
| Class Loading Time         | Time   |    0.00020313 s |                           0.00031996 s | +0.00011683 s |
| Execution Time             | Time   |    0.00001287 s |                           0.00102711 s | +0.00101423 s |
| From Start to End          | Memory |         0.10 MB |                                0.92 MB |      +0.82 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                0.84 MB |      +0.84 MB |
| Class Loading Time         | Memory |         0.09 MB |                                0.05 MB |      -0.05 MB |
| Execution Time             | Memory |         0.00 MB |                                0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (20 aspects, 20 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.00480914 s |                           0.00475597 s | -0.00005317 s |
| Boot Time - Kernel::init() | Time   |        0.00340486 s |                           0.00340605 s | +0.00000119 s |
| Class Loading Time         | Time   |        0.00032687 s |                           0.00031996 s | -0.00000691 s |
| Execution Time             | Time   |        0.00107312 s |                           0.00102711 s | -0.00004601 s |
| From Start to End          | Memory |             0.92 MB |                                0.92 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             0.84 MB |                                0.84 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.05 MB |                                0.05 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (50 aspects, 50 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00089288 s | 0.11557102 s | +0.11467814 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.00441885 s | +0.00441790 s |
| Class Loading Time         | Time   |    0.00078201 s | 0.10561490 s | +0.10483289 s |
| Execution Time             | Time   |    0.00010610 s | 0.00553012 s | +0.00542402 s |
| From Start to End          | Memory |         0.14 MB |      8.11 MB |      +7.97 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      0.93 MB |      +0.93 MB |
| Class Loading Time         | Memory |         0.14 MB |      7.15 MB |      +7.01 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (50 aspects, 50 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00089288 s |        0.01041102 s | +0.00951815 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.00395012 s | +0.00394917 s |
| Class Loading Time         | Time   |    0.00078201 s |        0.00050998 s | -0.00027204 s |
| Execution Time             | Time   |    0.00010610 s |        0.00594497 s | +0.00583887 s |
| From Start to End          | Memory |         0.14 MB |             1.11 MB |      +0.97 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             0.97 MB |      +0.97 MB |
| Class Loading Time         | Memory |         0.14 MB |             0.05 MB |      -0.09 MB |
| Execution Time             | Memory |         0.00 MB |             0.09 MB |      +0.09 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (50 aspects, 50 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00089288 s |                           0.01123405 s | +0.01034117 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.00543499 s | +0.00543404 s |
| Class Loading Time         | Time   |    0.00078201 s |                           0.00042510 s | -0.00035691 s |
| Execution Time             | Time   |    0.00010610 s |                           0.00536990 s | +0.00526381 s |
| From Start to End          | Memory |         0.14 MB |                                1.11 MB |      +0.97 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                0.97 MB |      +0.97 MB |
| Class Loading Time         | Memory |         0.14 MB |                                0.05 MB |      -0.09 MB |
| Execution Time             | Memory |         0.00 MB |                                0.09 MB |      +0.09 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (50 aspects, 50 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.01041102 s |                           0.01123405 s | +0.00082302 s |
| Boot Time - Kernel::init() | Time   |        0.00395012 s |                           0.00543499 s | +0.00148487 s |
| Class Loading Time         | Time   |        0.00050998 s |                           0.00042510 s | -0.00008488 s |
| Execution Time             | Time   |        0.00594497 s |                           0.00536990 s | -0.00057507 s |
| From Start to End          | Memory |             1.11 MB |                                1.11 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             0.97 MB |                                0.97 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.05 MB |                                0.05 MB |       0.00 MB |
| Execution Time             | Memory |             0.09 MB |                                0.09 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (100 aspects, 100 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00098896 s | 0.20841599 s | +0.20742702 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s | 0.00462294 s | +0.00462294 s |
| Class Loading Time         | Time   |    0.00074410 s | 0.18271303 s | +0.18196893 s |
| Execution Time             | Time   |    0.00024104 s | 0.02107310 s | +0.02083206 s |
| From Start to End          | Memory |         0.28 MB |      9.47 MB |      +9.18 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      1.18 MB |      +1.18 MB |
| Class Loading Time         | Memory |         0.28 MB |      8.26 MB |      +7.98 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (100 aspects, 100 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00098896 s |        0.02650499 s | +0.02551603 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |        0.00467992 s | +0.00467992 s |
| Class Loading Time         | Time   |    0.00074410 s |        0.00090599 s | +0.00016189 s |
| Execution Time             | Time   |    0.00024104 s |        0.02091408 s | +0.02067304 s |
| From Start to End          | Memory |         0.28 MB |             1.34 MB |      +1.05 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             1.25 MB |      +1.25 MB |
| Class Loading Time         | Memory |         0.28 MB |             0.06 MB |      -0.22 MB |
| Execution Time             | Memory |         0.00 MB |             0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (100 aspects, 100 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00098896 s |                           0.02676392 s | +0.02577496 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |                           0.00470805 s | +0.00470805 s |
| Class Loading Time         | Time   |    0.00074410 s |                           0.00082803 s | +0.00008392 s |
| Execution Time             | Time   |    0.00024104 s |                           0.02122307 s | +0.02098203 s |
| From Start to End          | Memory |         0.28 MB |                                1.34 MB |      +1.05 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                1.25 MB |      +1.25 MB |
| Class Loading Time         | Memory |         0.28 MB |                                0.06 MB |      -0.22 MB |
| Execution Time             | Memory |         0.00 MB |                                0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (100 aspects, 100 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.02650499 s |                           0.02676392 s | +0.00025892 s |
| Boot Time - Kernel::init() | Time   |        0.00467992 s |                           0.00470805 s | +0.00002813 s |
| Class Loading Time         | Time   |        0.00090599 s |                           0.00082803 s | -0.00007796 s |
| Execution Time             | Time   |        0.02091408 s |                           0.02122307 s | +0.00030899 s |
| From Start to End          | Memory |             1.34 MB |                                1.34 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             1.25 MB |                                1.25 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.06 MB |                                0.06 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (500 aspects, 100 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00529599 s | 0.89113784 s | +0.88584185 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.01167393 s | +0.01167297 s |
| Class Loading Time         | Time   |    0.00414181 s | 0.77507305 s | +0.77093124 s |
| Execution Time             | Time   |    0.00114894 s | 0.10438299 s | +0.10323405 s |
| From Start to End          | Memory |         1.37 MB |     11.98 MB |     +10.62 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      2.99 MB |      +2.99 MB |
| Class Loading Time         | Memory |         1.36 MB |      8.96 MB |      +7.60 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (500 aspects, 100 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00529599 s |        0.13686991 s | +0.13157392 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.01270199 s | +0.01270103 s |
| Class Loading Time         | Time   |    0.00414181 s |        0.01657486 s | +0.01243305 s |
| Execution Time             | Time   |    0.00114894 s |        0.10758591 s | +0.10643697 s |
| From Start to End          | Memory |         1.37 MB |             3.40 MB |      +2.03 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             3.18 MB |      +3.18 MB |
| Class Loading Time         | Memory |         1.36 MB |             0.18 MB |      -1.18 MB |
| Execution Time             | Memory |         0.00 MB |             0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (500 aspects, 100 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00529599 s |                           0.13024092 s | +0.12494493 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.01150513 s | +0.01150417 s |
| Class Loading Time         | Time   |    0.00414181 s |                           0.01352906 s | +0.00938725 s |
| Execution Time             | Time   |    0.00114894 s |                           0.10520101 s | +0.10405207 s |
| From Start to End          | Memory |         1.37 MB |                                3.40 MB |      +2.03 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                3.18 MB |      +3.18 MB |
| Class Loading Time         | Memory |         1.36 MB |                                0.18 MB |      -1.18 MB |
| Execution Time             | Memory |         0.00 MB |                                0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (500 aspects, 100 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.13686991 s |                           0.13024092 s | -0.00662899 s |
| Boot Time - Kernel::init() | Time   |        0.01270199 s |                           0.01150513 s | -0.00119686 s |
| Class Loading Time         | Time   |        0.01657486 s |                           0.01352906 s | -0.00304580 s |
| Execution Time             | Time   |        0.10758591 s |                           0.10520101 s | -0.00238490 s |
| From Start to End          | Memory |             3.40 MB |                                3.40 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             3.18 MB |                                3.18 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.18 MB |                                0.18 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (100 aspects, 500 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00263381 s | 0.29192710 s | +0.28929329 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s | 0.00451517 s | +0.00451517 s |
| Class Loading Time         | Time   |    0.00097108 s | 0.18082595 s | +0.17985487 s |
| Execution Time             | Time   |    0.00165701 s | 0.10658002 s | +0.10492301 s |
| From Start to End          | Memory |         0.28 MB |      9.47 MB |      +9.18 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      1.18 MB |      +1.18 MB |
| Class Loading Time         | Memory |         0.28 MB |      8.26 MB |      +7.98 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (100 aspects, 500 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00263381 s |        0.11770320 s | +0.11506939 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |        0.00455403 s | +0.00455403 s |
| Class Loading Time         | Time   |    0.00097108 s |        0.00165701 s | +0.00068593 s |
| Execution Time             | Time   |    0.00165701 s |        0.11148596 s | +0.10982895 s |
| From Start to End          | Memory |         0.28 MB |             1.34 MB |      +1.05 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             1.25 MB |      +1.25 MB |
| Class Loading Time         | Memory |         0.28 MB |             0.06 MB |      -0.22 MB |
| Execution Time             | Memory |         0.00 MB |             0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (100 aspects, 500 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00263381 s |                           0.11475515 s | +0.11212134 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |                           0.00477695 s | +0.00477695 s |
| Class Loading Time         | Time   |    0.00097108 s |                           0.00159287 s | +0.00062180 s |
| Execution Time             | Time   |    0.00165701 s |                           0.10838103 s | +0.10672402 s |
| From Start to End          | Memory |         0.28 MB |                                1.34 MB |      +1.05 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                1.25 MB |      +1.25 MB |
| Class Loading Time         | Memory |         0.28 MB |                                0.06 MB |      -0.22 MB |
| Execution Time             | Memory |         0.00 MB |                                0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (100 aspects, 500 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.11770320 s |                           0.11475515 s | -0.00294805 s |
| Boot Time - Kernel::init() | Time   |        0.00455403 s |                           0.00477695 s | +0.00022292 s |
| Class Loading Time         | Time   |        0.00165701 s |                           0.00159287 s | -0.00006413 s |
| Execution Time             | Time   |        0.11148596 s |                           0.10838103 s | -0.00310493 s |
| From Start to End          | Memory |             1.34 MB |                                1.34 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             1.25 MB |                                1.25 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.06 MB |                                0.06 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (500 aspects, 500 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.00928497 s | 1.35806179 s | +1.34877682 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s | 0.01119709 s | +0.01119709 s |
| Class Loading Time         | Time   |    0.00407910 s | 0.79515910 s | +0.79108000 s |
| Execution Time             | Time   |    0.00519896 s | 0.55169797 s | +0.54649901 s |
| From Start to End          | Memory |         1.37 MB |     10.95 MB |      +9.58 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      2.98 MB |      +2.98 MB |
| Class Loading Time         | Memory |         1.30 MB |      7.94 MB |      +6.64 MB |
| Execution Time             | Memory |         0.06 MB |      0.03 MB |      -0.04 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (500 aspects, 500 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.00928497 s |        0.56013393 s | +0.55084896 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |        0.01166320 s | +0.01166320 s |
| Class Loading Time         | Time   |    0.00407910 s |        0.01392293 s | +0.00984383 s |
| Execution Time             | Time   |    0.00519896 s |        0.53454185 s | +0.52934289 s |
| From Start to End          | Memory |         1.37 MB |             3.40 MB |      +2.03 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             3.18 MB |      +3.18 MB |
| Class Loading Time         | Memory |         1.30 MB |             0.18 MB |      -1.12 MB |
| Execution Time             | Memory |         0.06 MB |             0.03 MB |      -0.04 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (500 aspects, 500 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.00928497 s |                           0.56933188 s | +0.56004691 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |                           0.01180196 s | +0.01180196 s |
| Class Loading Time         | Time   |    0.00407910 s |                           0.01509190 s | +0.01101279 s |
| Execution Time             | Time   |    0.00519896 s |                           0.54243207 s | +0.53723311 s |
| From Start to End          | Memory |         1.37 MB |                                3.40 MB |      +2.03 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                3.18 MB |      +3.18 MB |
| Class Loading Time         | Memory |         1.30 MB |                                0.18 MB |      -1.12 MB |
| Execution Time             | Memory |         0.06 MB |                                0.03 MB |      -0.04 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (500 aspects, 500 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        0.56013393 s |                           0.56933188 s | +0.00919795 s |
| Boot Time - Kernel::init() | Time   |        0.01166320 s |                           0.01180196 s | +0.00013876 s |
| Class Loading Time         | Time   |        0.01392293 s |                           0.01509190 s | +0.00116897 s |
| Execution Time             | Time   |        0.53454185 s |                           0.54243207 s | +0.00789022 s |
| From Start to End          | Memory |             3.40 MB |                                3.40 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             3.18 MB |                                3.18 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.18 MB |                                0.18 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (1000 aspects, 500 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.01730800 s | 2.72424984 s | +2.70694184 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.02090693 s | +0.02090597 s |
| Class Loading Time         | Time   |    0.00716209 s | 1.62215781 s | +1.61499572 s |
| Execution Time             | Time   |    0.01014113 s | 1.08117795 s | +1.07103682 s |
| From Start to End          | Memory |         2.68 MB |     13.87 MB |     +11.19 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      5.94 MB |      +5.94 MB |
| Class Loading Time         | Memory |         2.68 MB |      7.91 MB |      +5.22 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (1000 aspects, 500 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.01730800 s |        1.13786697 s | +1.12055898 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.01966286 s | +0.01966190 s |
| Class Loading Time         | Time   |    0.00716209 s |        0.05431199 s | +0.04714990 s |
| Execution Time             | Time   |    0.01014113 s |        1.06388593 s | +1.05374479 s |
| From Start to End          | Memory |         2.68 MB |             7.05 MB |      +4.36 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             5.99 MB |      +5.99 MB |
| Class Loading Time         | Memory |         2.68 MB |             0.19 MB |      -2.49 MB |
| Execution Time             | Memory |         0.00 MB |             0.86 MB |      +0.86 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (1000 aspects, 500 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.01730800 s |                           1.13636208 s | +1.11905408 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.01938319 s | +0.01938224 s |
| Class Loading Time         | Time   |    0.00716209 s |                           0.05254292 s | +0.04538083 s |
| Execution Time             | Time   |    0.01014113 s |                           1.06443000 s | +1.05428886 s |
| From Start to End          | Memory |         2.68 MB |                                7.05 MB |      +4.36 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                5.99 MB |      +5.99 MB |
| Class Loading Time         | Memory |         2.68 MB |                                0.19 MB |      -2.49 MB |
| Execution Time             | Memory |         0.00 MB |                                0.86 MB |      +0.86 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (1000 aspects, 500 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        1.13786697 s |                           1.13636208 s | -0.00150490 s |
| Boot Time - Kernel::init() | Time   |        0.01966286 s |                           0.01938319 s | -0.00027966 s |
| Class Loading Time         | Time   |        0.05431199 s |                           0.05254292 s | -0.00176907 s |
| Execution Time             | Time   |        1.06388593 s |                           1.06443000 s | +0.00054407 s |
| From Start to End          | Memory |             7.05 MB |                                7.05 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             5.99 MB |                                5.99 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.19 MB |                                0.19 MB |       0.00 MB |
| Execution Time             | Memory |             0.86 MB |                                0.86 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (500 aspects, 1000 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.01360583 s | 1.86903214 s | +1.85542631 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s | 0.01099682 s | +0.01099586 s |
| Class Loading Time         | Time   |    0.00365710 s | 0.78261685 s | +0.77895975 s |
| Execution Time             | Time   |    0.00994301 s | 1.07541180 s | +1.06546879 s |
| From Start to End          | Memory |         1.37 MB |     10.95 MB |      +9.58 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      2.98 MB |      +2.98 MB |
| Class Loading Time         | Memory |         1.30 MB |      7.94 MB |      +6.64 MB |
| Execution Time             | Memory |         0.06 MB |      0.03 MB |      -0.04 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (500 aspects, 1000 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.01360583 s |        1.09529495 s | +1.08168912 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.01129985 s | +0.01129889 s |
| Class Loading Time         | Time   |    0.00365710 s |        0.01311183 s | +0.00945473 s |
| Execution Time             | Time   |    0.00994301 s |        1.07087708 s | +1.06093407 s |
| From Start to End          | Memory |         1.37 MB |             3.40 MB |      +2.03 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             3.18 MB |      +3.18 MB |
| Class Loading Time         | Memory |         1.30 MB |             0.18 MB |      -1.12 MB |
| Execution Time             | Memory |         0.06 MB |             0.03 MB |      -0.04 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (500 aspects, 1000 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.01360583 s |                           1.11949301 s | +1.10588717 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.01177502 s | +0.01177406 s |
| Class Loading Time         | Time   |    0.00365710 s |                           0.01410890 s | +0.01045179 s |
| Execution Time             | Time   |    0.00994301 s |                           1.09360194 s | +1.08365893 s |
| From Start to End          | Memory |         1.37 MB |                                3.40 MB |      +2.03 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                3.18 MB |      +3.18 MB |
| Class Loading Time         | Memory |         1.30 MB |                                0.18 MB |      -1.12 MB |
| Execution Time             | Memory |         0.06 MB |                                0.03 MB |      -0.04 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (500 aspects, 1000 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        1.09529495 s |                           1.11949301 s | +0.02419806 s |
| Boot Time - Kernel::init() | Time   |        0.01129985 s |                           0.01177502 s | +0.00047517 s |
| Class Loading Time         | Time   |        0.01311183 s |                           0.01410890 s | +0.00099707 s |
| Execution Time             | Time   |        1.07087708 s |                           1.09360194 s | +0.02272487 s |
| From Start to End          | Memory |             3.40 MB |                                3.40 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             3.18 MB |                                3.18 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.18 MB |                                0.18 MB |       0.00 MB |
| Execution Time             | Memory |             0.03 MB |                                0.03 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (1000 aspects, 1000 executions)
+----------------------------+--------+-----------------+--------------+---------------+
| Measure Type               | Metric | Without Aspects | With Aspects |    Difference |
+----------------------------+--------+-----------------+--------------+---------------+
| From Start to End          | Time   |    0.02874398 s | 3.81947207 s | +3.79072809 s |
| Boot Time - Kernel::init() | Time   |    0.00000215 s | 0.01850390 s | +0.01850176 s |
| Class Loading Time         | Time   |    0.00760984 s | 1.61046791 s | +1.60285807 s |
| Execution Time             | Time   |    0.02112603 s | 2.19049311 s | +2.16936707 s |
| From Start to End          | Memory |         2.69 MB |     15.02 MB |     +12.33 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      5.63 MB |      +5.63 MB |
| Class Loading Time         | Memory |         2.69 MB |      9.36 MB |      +6.67 MB |
| Execution Time             | Memory |         0.00 MB |      0.03 MB |      +0.03 MB |
+----------------------------+--------+-----------------+--------------+---------------+

Table 2: Without Aspects vs With Cached Aspects (1000 aspects, 1000 executions)
+----------------------------+--------+-----------------+---------------------+---------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |    Difference |
+----------------------------+--------+-----------------+---------------------+---------------+
| From Start to End          | Time   |    0.02874398 s |        2.21837807 s | +2.18963408 s |
| Boot Time - Kernel::init() | Time   |    0.00000215 s |        0.01957893 s | +0.01957679 s |
| Class Loading Time         | Time   |    0.00760984 s |        0.05409193 s | +0.04648209 s |
| Execution Time             | Time   |    0.02112603 s |        2.14470196 s | +2.12357593 s |
| From Start to End          | Memory |         2.69 MB |             7.05 MB |      +4.35 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             5.99 MB |      +5.99 MB |
| Class Loading Time         | Memory |         2.69 MB |             0.19 MB |      -2.50 MB |
| Execution Time             | Memory |         0.00 MB |             0.86 MB |      +0.86 MB |
+----------------------------+--------+-----------------+---------------------+---------------+

Table 3: Without Aspects vs Production (1000 aspects, 1000 executions)
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+-----------------+----------------------------------------+---------------+
| From Start to End          | Time   |    0.02874398 s |                           2.25499701 s | +2.22625303 s |
| Boot Time - Kernel::init() | Time   |    0.00000215 s |                           0.01971507 s | +0.01971292 s |
| Class Loading Time         | Time   |    0.00760984 s |                           0.05734992 s | +0.04974008 s |
| Execution Time             | Time   |    0.02112603 s |                           2.17792392 s | +2.15679789 s |
| From Start to End          | Memory |         2.69 MB |                                7.05 MB |      +4.35 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                5.99 MB |      +5.99 MB |
| Class Loading Time         | Memory |         2.69 MB |                                0.19 MB |      -2.50 MB |
| Execution Time             | Memory |         0.00 MB |                                0.86 MB |      +0.86 MB |
+----------------------------+--------+-----------------+----------------------------------------+---------------+

Table 4: With Cached Aspects vs Production (1000 aspects, 1000 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |        2.21837807 s |                           2.25499701 s | +0.03661895 s |
| Boot Time - Kernel::init() | Time   |        0.01957893 s |                           0.01971507 s | +0.00013614 s |
| Class Loading Time         | Time   |        0.05409193 s |                           0.05734992 s | +0.00325799 s |
| Execution Time             | Time   |        2.14470196 s |                           2.17792392 s | +0.03322196 s |
| From Start to End          | Memory |             7.05 MB |                                7.05 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             5.99 MB |                                5.99 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.19 MB |                                0.19 MB |       0.00 MB |
| Execution Time             | Memory |             0.86 MB |                                0.86 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (5000 aspects, 1000 executions)
+----------------------------+--------+-----------------+---------------+----------------+
| Measure Type               | Metric | Without Aspects |  With Aspects |     Difference |
+----------------------------+--------+-----------------+---------------+----------------+
| From Start to End          | Time   |    0.14809799 s | 22.38378406 s | +22.23568606 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |  0.08785295 s |  +0.08785200 s |
| Class Loading Time         | Time   |    0.03779912 s |  8.97636414 s |  +8.93856502 s |
| Execution Time             | Time   |    0.11029196 s | 13.31956005 s | +13.20926809 s |
| From Start to End          | Memory |        14.38 MB |      38.53 MB |      +24.15 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      25.55 MB |      +25.55 MB |
| Class Loading Time         | Memory |        14.19 MB |      12.79 MB |       -1.40 MB |
| Execution Time             | Memory |         0.19 MB |       0.19 MB |        0.00 MB |
+----------------------------+--------+-----------------+---------------+----------------+

Table 2: Without Aspects vs With Cached Aspects (5000 aspects, 1000 executions)
+----------------------------+--------+-----------------+---------------------+----------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |     Difference |
+----------------------------+--------+-----------------+---------------------+----------------+
| From Start to End          | Time   |    0.14809799 s |       12.80209589 s | +12.65399790 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.08980703 s |  +0.08980608 s |
| Class Loading Time         | Time   |    0.03779912 s |        1.54771519 s |  +1.50991607 s |
| Execution Time             | Time   |    0.11029196 s |       11.16456699 s | +11.05427504 s |
| From Start to End          | Memory |        14.38 MB |            31.56 MB |      +17.18 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |            28.53 MB |      +28.53 MB |
| Class Loading Time         | Memory |        14.19 MB |             0.89 MB |      -13.30 MB |
| Execution Time             | Memory |         0.19 MB |             2.15 MB |       +1.96 MB |
+----------------------------+--------+-----------------+---------------------+----------------+

Table 3: Without Aspects vs Production (5000 aspects, 1000 executions)
+----------------------------+--------+-----------------+----------------------------------------+----------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |     Difference |
+----------------------------+--------+-----------------+----------------------------------------+----------------+
| From Start to End          | Time   |    0.14809799 s |                          12.80358791 s | +12.65548992 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.08354807 s |  +0.08354712 s |
| Class Loading Time         | Time   |    0.03779912 s |                           1.54318619 s |  +1.50538707 s |
| Execution Time             | Time   |    0.11029196 s |                          11.17684698 s | +11.06655502 s |
| From Start to End          | Memory |        14.38 MB |                               31.56 MB |      +17.18 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                               28.53 MB |      +28.53 MB |
| Class Loading Time         | Memory |        14.19 MB |                                0.89 MB |      -13.30 MB |
| Execution Time             | Memory |         0.19 MB |                                2.15 MB |       +1.96 MB |
+----------------------------+--------+-----------------+----------------------------------------+----------------+

Table 4: With Cached Aspects vs Production (5000 aspects, 1000 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |       12.80209589 s |                          12.80358791 s | +0.00149202 s |
| Boot Time - Kernel::init() | Time   |        0.08980703 s |                           0.08354807 s | -0.00625896 s |
| Class Loading Time         | Time   |        1.54771519 s |                           1.54318619 s | -0.00452900 s |
| Execution Time             | Time   |       11.16456699 s |                          11.17684698 s | +0.01227999 s |
| From Start to End          | Memory |            31.56 MB |                               31.56 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |            28.53 MB |                               28.53 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.89 MB |                                0.89 MB |       0.00 MB |
| Execution Time             | Memory |             2.15 MB |                                2.15 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (1000 aspects, 5000 executions)
+----------------------------+--------+-----------------+---------------+----------------+
| Measure Type               | Metric | Without Aspects |  With Aspects |     Difference |
+----------------------------+--------+-----------------+---------------+----------------+
| From Start to End          | Time   |    0.12256098 s | 12.56647205 s | +12.44391108 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |  0.01892114 s |  +0.01892114 s |
| Class Loading Time         | Time   |    0.01113105 s |  1.58789301 s |  +1.57676196 s |
| Execution Time             | Time   |    0.11142182 s | 10.95964980 s | +10.84822798 s |
| From Start to End          | Memory |         2.69 MB |      15.02 MB |      +12.33 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |       5.63 MB |       +5.63 MB |
| Class Loading Time         | Memory |         2.69 MB |       9.36 MB |       +6.67 MB |
| Execution Time             | Memory |         0.00 MB |       0.03 MB |       +0.03 MB |
+----------------------------+--------+-----------------+---------------+----------------+

Table 2: Without Aspects vs With Cached Aspects (1000 aspects, 5000 executions)
+----------------------------+--------+-----------------+---------------------+----------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |     Difference |
+----------------------------+--------+-----------------+---------------------+----------------+
| From Start to End          | Time   |    0.12256098 s |       11.05274296 s | +10.93018198 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |        0.01938581 s |  +0.01938581 s |
| Class Loading Time         | Time   |    0.01113105 s |        0.05558491 s |  +0.04445386 s |
| Execution Time             | Time   |    0.11142182 s |       10.97776699 s | +10.86634517 s |
| From Start to End          | Memory |         2.69 MB |             7.05 MB |       +4.35 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |             5.99 MB |       +5.99 MB |
| Class Loading Time         | Memory |         2.69 MB |             0.19 MB |       -2.50 MB |
| Execution Time             | Memory |         0.00 MB |             0.86 MB |       +0.86 MB |
+----------------------------+--------+-----------------+---------------------+----------------+

Table 3: Without Aspects vs Production (1000 aspects, 5000 executions)
+----------------------------+--------+-----------------+----------------------------------------+----------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |     Difference |
+----------------------------+--------+-----------------+----------------------------------------+----------------+
| From Start to End          | Time   |    0.12256098 s |                          10.95230103 s | +10.82974005 s |
| Boot Time - Kernel::init() | Time   |    0.00000000 s |                           0.02022314 s |  +0.02022314 s |
| Class Loading Time         | Time   |    0.01113105 s |                           0.05416012 s |  +0.04302907 s |
| Execution Time             | Time   |    0.11142182 s |                          10.87791109 s | +10.76648927 s |
| From Start to End          | Memory |         2.69 MB |                                7.05 MB |       +4.35 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                                5.99 MB |       +5.99 MB |
| Class Loading Time         | Memory |         2.69 MB |                                0.19 MB |       -2.50 MB |
| Execution Time             | Memory |         0.00 MB |                                0.86 MB |       +0.86 MB |
+----------------------------+--------+-----------------+----------------------------------------+----------------+

Table 4: With Cached Aspects vs Production (1000 aspects, 5000 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |       11.05274296 s |                          10.95230103 s | -0.10044193 s |
| Boot Time - Kernel::init() | Time   |        0.01938581 s |                           0.02022314 s | +0.00083733 s |
| Class Loading Time         | Time   |        0.05558491 s |                           0.05416012 s | -0.00142479 s |
| Execution Time             | Time   |       10.97776699 s |                          10.87791109 s | -0.09985590 s |
| From Start to End          | Memory |             7.05 MB |                                7.05 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |             5.99 MB |                                5.99 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.19 MB |                                0.19 MB |       0.00 MB |
| Execution Time             | Memory |             0.86 MB |                                0.86 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

Table 1: Without Aspects vs With Aspects (5000 aspects, 5000 executions)
+----------------------------+--------+-----------------+---------------+----------------+
| Measure Type               | Metric | Without Aspects |  With Aspects |     Difference |
+----------------------------+--------+-----------------+---------------+----------------+
| From Start to End          | Time   |    0.55696797 s | 80.14979291 s | +79.59282494 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |  0.08371711 s |  +0.08371615 s |
| Class Loading Time         | Time   |    0.03312802 s | 10.14378715 s | +10.11065912 s |
| Execution Time             | Time   |    0.52383184 s | 69.92228103 s | +69.39844918 s |
| From Start to End          | Memory |        14.43 MB |      39.02 MB |      +24.59 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |      26.74 MB |      +26.74 MB |
| Class Loading Time         | Memory |        14.24 MB |      12.06 MB |       -2.18 MB |
| Execution Time             | Memory |         0.19 MB |       0.21 MB |       +0.03 MB |
+----------------------------+--------+-----------------+---------------+----------------+

Table 2: Without Aspects vs With Cached Aspects (5000 aspects, 5000 executions)
+----------------------------+--------+-----------------+---------------------+----------------+
| Measure Type               | Metric | Without Aspects | With Cached Aspects |     Difference |
+----------------------------+--------+-----------------+---------------------+----------------+
| From Start to End          | Time   |    0.55696797 s |       57.52734709 s | +56.97037911 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |        0.08776498 s |  +0.08776402 s |
| Class Loading Time         | Time   |    0.03312802 s |        1.55593491 s |  +1.52280688 s |
| Execution Time             | Time   |    0.52383184 s |       55.88363886 s | +55.35980701 s |
| From Start to End          | Memory |        14.43 MB |            31.56 MB |      +17.13 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |            28.53 MB |      +28.53 MB |
| Class Loading Time         | Memory |        14.24 MB |             0.89 MB |      -13.36 MB |
| Execution Time             | Memory |         0.19 MB |             2.15 MB |       +1.96 MB |
+----------------------------+--------+-----------------+---------------------+----------------+

Table 3: Without Aspects vs Production (5000 aspects, 5000 executions)
+----------------------------+--------+-----------------+----------------------------------------+----------------+
| Measure Type               | Metric | Without Aspects | Production - Cache will not be checked |     Difference |
+----------------------------+--------+-----------------+----------------------------------------+----------------+
| From Start to End          | Time   |    0.55696797 s |                          57.82719707 s | +57.27022910 s |
| Boot Time - Kernel::init() | Time   |    0.00000095 s |                           0.08919621 s |  +0.08919525 s |
| Class Loading Time         | Time   |    0.03312802 s |                           1.68186593 s |  +1.64873791 s |
| Execution Time             | Time   |    0.52383184 s |                          56.05612898 s | +55.53229713 s |
| From Start to End          | Memory |        14.43 MB |                               31.56 MB |      +17.13 MB |
| Boot Time - Kernel::init() | Memory |         0.00 MB |                               28.53 MB |      +28.53 MB |
| Class Loading Time         | Memory |        14.24 MB |                                0.89 MB |      -13.36 MB |
| Execution Time             | Memory |         0.19 MB |                                2.15 MB |       +1.96 MB |
+----------------------------+--------+-----------------+----------------------------------------+----------------+

Table 4: With Cached Aspects vs Production (5000 aspects, 5000 executions)
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| Measure Type               | Metric | With Cached Aspects | Production - Cache will not be checked |    Difference |
+----------------------------+--------+---------------------+----------------------------------------+---------------+
| From Start to End          | Time   |       57.52734709 s |                          57.82719707 s | +0.29984999 s |
| Boot Time - Kernel::init() | Time   |        0.08776498 s |                           0.08919621 s | +0.00143123 s |
| Class Loading Time         | Time   |        1.55593491 s |                           1.68186593 s | +0.12593102 s |
| Execution Time             | Time   |       55.88363886 s |                          56.05612898 s | +0.17249012 s |
| From Start to End          | Memory |            31.56 MB |                               31.56 MB |       0.00 MB |
| Boot Time - Kernel::init() | Memory |            28.53 MB |                               28.53 MB |       0.00 MB |
| Class Loading Time         | Memory |             0.89 MB |                                0.89 MB |       0.00 MB |
| Execution Time             | Memory |             2.15 MB |                                2.15 MB |       0.00 MB |
+----------------------------+--------+---------------------+----------------------------------------+---------------+

I will commit this on an extra branch next week and also do some benchmarking for general performance improvements :)

Thanks for the response.
What does the cache checking mechanism do?
I guess it has to look at every proxy file. Probably on slower filesystems then the difference should be bigger.

@WalterWoshid hey, any updates?

Hi @djschilling,
I have added the Production/Development environments feature as an option. I have also refactored the tests to use "service classes vs aspects" instead of "copies of the target class vs aspects" for a better comparison, check out the benchmarks in the PHPUnit Performance Tests section.
Sadly the issue still persists that the Production environment is sometimes slower than the cached variant, even though it executes less code and should be faster theoretically, maybe there is a simple problem how I measure performance in the tests.
The Production/Development feature is now an option that can be used like the other options in the AopKernel and I have also added a protected function configureOptions(): void method, which allows users to dynamically change options :)

About your question what the cache checking mechanism does:
The default ClassLoader of Composer handles the whole class loading logic which I override with my own AOP Class Loader. There is a findFile method which converts a PHP Namespace to a resolvable file path.
Here is the overwritten findFile method of my AOP Class Loader:
public function findFile($namespacedClass): false|string
{
    // Executes the original findFile method of Composer
    $filePath = $this->originalClassLoader->findFile($namespacedClass);

    // Additional logic...

    // Here the cache state is queried from the `cache_states.php` file
    // If it doesn't exist, it just returns null
    $cacheState = $this->cacheStateManager->queryCacheState($filePath);

    // This is for debugging and just skips the conditions below if `true` and that way the cache will not be used at all
    if ($this->options->isDebug()) {
        // ...
    }

    // First I check if the Production Environment is chosen and also if a cache state exists
    // If a cache state exists, load the cached file path or use original file path if the cache is a `EmptyResultCacheState` (no aspects are applied to it)
    elseif ($this->options->getEnvironment() === Environment::PRODUCTION
        && $cacheState
    ) {
        return $cacheState->getFilePath() ?? $filePath;
    }

    // In the development mode the same thing happens as above, but also `->isFresh()` is called
    elseif ($this->options->getEnvironment() === Environment::DEVELOPMENT
        && $cacheState
        && $cacheState->isFresh()
    ) {
        return $cacheState->getFilePath() ?? $filePath;
    }

    // Here the aspects will be matched and loaded ...
}

The ->isFresh() method is implemented in multiple classes: WovenCacheState (If aspects have been applied) and the base CacheState which is the parent of every other cache state.
Here is the ->isFresh() method of the WovenCacheState class:
public function isFresh(): bool
{
    // This checks the `->isFresh()` of the base `CacheState` class
    if (!parent::isFresh()) {
        return false;
    }

    // Proxy file exists
    if (!file_exists($this->proxyFilePath)) {
        return false;
    }

    // Woven file exists
    if (!file_exists($this->wovenFilePath)) {
        return false;
    }

    // Collect transformer (from Okapi/Code-Transformer) and aspect file paths
    $transformerAndAspectFilePaths = array_merge(
        $this->transformerFilePaths,
        $this->aspectFilePaths,
    );
    foreach ($transformerAndAspectFilePaths as $filePath) {
        // File exists
        if (!file_exists($filePath)) {
            return false;
        }
    }

    return true;
}

And here is the ->isFresh() method of the base CacheState class:
public function isFresh(): bool
{
    // Original file exists
    if (!file_exists($this->originalFilePath)) {
        return false;
    }

    // Original file has been modified
    if (filemtime($this->originalFilePath) > $this->modificationTime) {
        return false;
    }

    return true;
}

I have tested all possible configurations with the debugger and it seems to be working correctly, the file_exists function is pretty fast as far as I know, but why the Production environment is faster than the Development environment is still a puzzle to me.
Checkout Okapi/Aop - 1.2.7 for the new feature :)

Thanks for your work i will check it out.


[FLINK-33556] Test infrastructure for externalized python code

What is the purpose of the change
A few changes are needed in the original python test code, so the externalized connectors could run their tests
Brief change log
Marks the files with a comment which are used by the externalized connector tests:

link-python/dev/build-wheels.sh
flink-python/dev/install_command.sh
flink-python/dev/lint-python.sh

Adds a possibility to modify the test's classpath in flink-python/pyflink/pyflink_gateway_server.py
Verifying this change
Created the externalized tests for the kafka connector, and hacked this file to the downloaded infra and run the tests successfully.
Does this pull request potentially affect one of the following parts:

Dependencies (does it add or upgrade a dependency): no
The public API, i.e., is any changed class annotated with @Public(Evolving): no
The serializers: no
The runtime per-record code paths (performance sensitive): no
Anything that affects deployment or recovery: JobManager (and its components), Checkpointing, Kubernetes/Yarn, ZooKeeper: no
The S3 file system connector: no

Documentation

Does this pull request introduce a new feature? no
If yes, how is the feature documented? not applicable

If there are no further comments then I'm intended to merge this tomorrow.


Make tests stable on api level 21 and fix some typo

getInstrumentation().sendStringSync(text);

On api level 21, the tests are not stable, that's because after call sendStringSync("xxx"), you can't get stable value from editText.getText(), according to the official functional test sample, call waitForIdleSync() around sendStringSync() can fix this.

looks good to me
should be merged

Merge relevant commits to Forkhub: https://github.com/jonan/ForkHub/commit/2897b712b83a43134f101082decfc3f2cfff7546 https://github.com/jonan/ForkHub/commit/1b86f9f96c70f58eb69b44e4dffed8872a8eeb68
The other two commits aren't really related to tests.

@jonan What is the difference between forkhubs/android and jonan/ForkHub (you are displayed as owner of both) and to which of both should we send our pull requests to?

@hkliya can you include the relevant commit only?

@larsgrefer FYI forkhubs (with S) is the official spin-off from GitHub. Thus it still shows the contributing history as well as the number stars and forks.
jonan/ForkHub is his own version.

@hkliya Just set your master branch back to 835b9ff (removing the unnecessary merge commit)
git push origin master:835b9ff -f
(assuming your origin remote is 'https://github.com/hkliya/android.git')

@larsgrefer basically forkhubs/android is more focused on features and jonan/ForkHub on order and stability (already usable from Google Play).
You can send PR to whichever you want, I'll try to keep them in sync when commits apply to both anyway.

@fadils I was confused because jonan/ForkHub is not marked as fork of this (forkhubs/android) an because @jonan is marked as owner of both repos

@larsgrefer I'm confused too.

@jonan @fadils In my opinion we should focus on this repository because it's the (more or less) official one. Therefore it's nice that @jonan pulls pull requests to his version, but i'd like to see the contributions of me and others in this repo too.

@larsgrefer no worries, simply contribute to this repo.
If anything applies to jonan/ForkHub I'll cherry-pick it.

@jonan Ok, thanks
Then i just wait for reactions to my 7 open pull requests ;)
In the meantime we can merge this request via #777

Sorry for my late response. I will include only relative commits in one PR in the future. Thanks!


The hostname of the origin is unresolvable (DNS) or blocked by policy

I have deployed it according to Docker installation instructions
then:
CentOS 7
docker exec -it weserv /bin/bash #into the docker
then:
vi /etc/nginx/imagesweserv.conf
modify
resolver <IP_ADDRESS>;
to:
resolver <IP_ADDRESS> valid=5 ipv6=off;
or resolver <IP_ADDRESS>;
:wq
then:
nginx -s reload
in any case， it's failed and return the result as following:
{"status":"error","code":404,"message":"The hostname of the origin is unresolvable (DNS) or blocked by policy."}
and my test url, it's using cloudflare cdn to connect my centos server:
https://img.zuixinhanman.com/?w=470&h=250&fit=cover&url=https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png

Hi @guozili2,
What's the output of running:
# Check the DNS settings (ought to be inherited from the host when Docker's default bridge network is used)
$ cat /etc/resolv.conf | grep nameserver
# Install bind-utils for nslookup
$ dnf install -y bind-utils
# Try to resolve using the default DNS server(s) (specified in /etc/resolv.conf)
$ nslookup google.com
# ... and with Google's open DNS server
$ nslookup google.com <IP_ADDRESS>
# ... and with Docker's embedded DNS server (when using a user-defined bridge)
$ nslookup google.com <IP_ADDRESS>

within the container?

@guozili2 Are you able to answer the above question?

hello @kleisauke how are you?
im running on AWS and facing the same problems, what the output of your commands should be? so i can compare with my machine.

@fellipeamedeiros It depends on the current environment and OCI-compliant container runtime. For example, with Podman, I see:
$ podman run --rm -it --dns <IP_ADDRESS> --entrypoint bash ghcr.io/weserv/images:5.x
$ cat /etc/resolv.conf | grep nameserver
nameserver <IP_ADDRESS>
$ dnf install -y bind-utils
$ nslookup google.com
Server:		<IP_ADDRESS>
Address:	<IP_ADDRESS>#53

Non-authoritative answer:
Name:	google.com
Address: <IP_ADDRESS>
Name:	google.com
Address: 2a00:1450:400e:810::200e
$ nslookup google.com <IP_ADDRESS>
Server:		<IP_ADDRESS>
Address:	<IP_ADDRESS>#53

Non-authoritative answer:
Name:	google.com
Address: <IP_ADDRESS>
Name:	google.com
Address: 2a00:1450:400e:80d::200e
$ exit

So resolving google.com works both with CloudFlare's and Google's open DNS server. Docker's embedded DNS server should only be used if you use host networking (the --network host CLI argument).
By default we use Google's open DNS server, but this can be changed in /etc/nginx/imagesweserv.conf inside the pre-built Docker image.
https://github.com/weserv/images/blob/6dcca50caea32dfbb71336980a7826b483b80229/ngx_conf/imagesweserv.conf#L55
See https://github.com/weserv/images/issues/206#issuecomment-567015037 if looking up IPv6 addresses is not desired. However, this is not always recommended, since there are a numerous hosts that only support IPv6 and/or provide broken IPv4 fallbacks.

@kleisauke i have the result below
nslookup google.com
Server:         <IP_ADDRESS>
Address:        <IP_ADDRESS>#53
Non-authoritative answer:
Name:   google.com
Address: <IP_ADDRESS>
Name:   google.com
Address: <IP_ADDRESS>
Name:   google.com
Address: <IP_ADDRESS>
Name:   google.com
Address: <IP_ADDRESS>
Name:   google.com
Address: <IP_ADDRESS>
Name:   google.com
Address: <IP_ADDRESS>
Name:   google.com
Address: 2607:f8b0:4004:c17::65
Name:   google.com
Address: 2607:f8b0:4004:c17::8a
Name:   google.com
Address: 2607:f8b0:4004:c17::8b
Name:   google.com
Address: 2607:f8b0:4004:c17::64

@kleisauke and we need any specif ports? today i only have port 80/433 on outbound rules

@fellipeamedeiros Does nslookup google.com <IP_ADDRESS> work? Please open a new issue if it does not. You may also want to add a outbound rule for UDP port 53 to transmit DNS queries.

@kleisauke opening the port 53 works, thanks for your help

I hope this information helped. Please feel free to re-open if questions remain.


Integrate QuantAQ data from DEC?

Jingqiu mentioned that DEC has a new sensor network.  Will that information be accessible so we could add it to our map?

If we want to explore the transparency of this data on our own the new website (ArcGIS dashboard) for the network is here: https://experience.arcgis.com/experience/8655256b056a48f6a19788d43cdab30f
Is it public/accessible? These are kinda big (in terms of number of variables), perhaps we can just scrape AQI 10' and 24hr and display it the same as the PurpleAir sensors just with a different last line in the popup "This data provided by ADEC[link]".


How to show controls column wise in dailog.ts window

I want to show my controls in two or three in one row.
right now all of my property showing like one in a row.

https://github.com/volkanceylan/Serene/blob/master/Serene/Serene.Web/Modules/BasicSamples/Dialogs/MultiColumnResponsiveDialog/Index.cshtml

No friend i want when dialog box opens i want to show the control in columns not by row. like i have many checkbox i want to show them all in one row right now its all showing separate in new row each.

Where you wrote that code? under which file?

Under "site.less" write your own css for customizing fields in the dialog.

MyProject.Web\Content\site    *.less
If you did not create them for the module then by default site.less

:(

and how then i can integrate this css into my dialog?

Already everything is there, just find the file site.les
In it, find the .s-MyModul-xyzDialog {}
Add
.s-MyModul-xyzDialog {
    > .size {
        width: 1074px;
    }

    .caption {
        width: 110px;
    }
        .field.MyField1, .field.MyField2, .field.MyField3 {
            flex: auto;
            min-width: 200px;
            width: 25%;
        }
    }
}

and where can i write css to manage grid.ts columns ? to manage width

and where can i write css to manage grid.ts columns ? to manage width

thanks all for your helps, its worked i followed your instruction Zahar thank you friend.


[FLINK-15085][hs] Simplify dashboard config generation

Fixes an issue in the HistoryServer where the dashboard configuration JSON was generated manually, resulting in it being out-of-sync with the actual representation.
Instead we now use an ObjectMapper to directly map the object to json, just like how the REST handlers work.

Green travis: https://travis-ci.org/zentol/flink/builds/621505758

LGTM, thanks for making the fix 👍


Superseded Windows 7 Compatibility Update KB2952664 causes diagtrack.dll warning

KB2952664, containing diagtrack.dll v10.0.10586.3 shows as superseded in Windows Update Catalog by March'19/April'19 Monthly Quality Rollups (KB4489878, KB4493472), containing diagtrack.dll v10.0.10586.10007.
Organizations that deploy security-only updates to Windows 7 will not get updated diagtrack.dll, and Upgrade Readiness script will complain about it in the log:
"warning : CheckUTCKB The Diagnostics and Telemetry tracking service (diagtrack.dll version 10.0.10586.3) is old. 10.0.10586.10007 enables faster processing of insights and reduces overall latency for devices enrolled in Analytics. Learn more at https://go.microsoft.com/fwlink/?linkid=2011593&clcid=0x409"
FWLink in log file is dead, and this article does not notice the warning above, and if it can be safely ignored. Windows 7 devices also show up in "outdated KB" bucket in the Upgrade Readiness portal.
Thanks.

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: 4273a259-c3c7-dca7-6353-954068d740a7
Version Independent ID: 1084ea77-95c4-4e4a-da6c-f4d8668f9ebf
Content: Enrolling devices in Windows Analytics (Windows 10)
Content Source: windows/deployment/update/windows-analytics-get-started.md
Product: w10
Technology: windows
GitHub Login: @jaimeo
Microsoft Alias: jaimeo

Thanks for letting us know! I'll get with @zdvorak and get this corrected.

@officedocsbot assign @mypil

@jaimeo @zdvorak - Do you have any updates on this?
Thank you.

Dear @juanand ,
and this article does not notice the warning above - as you can see in the article, in the "Deploy the compatibility update and related updates" section: "We also recommend installing the latest Windows Monthly Rollup on Windows 7 and Windows 8.1 devices.", so the organizations that use only security updates should deploy monthly updates before deploying Windows Analytics. The warning means that the recommendations were ignored, I think that in this case it shouldn't be noticed in the article separately. What do you think?
FWLink in log file is dead - dear @mypil , the broken link issue should be addressed to the team responsible for Upgrade Readiness
Thank you

I've looked up the owner of the FWlink and let them know. @zdvorak did you have any input on the other question?

@jaimeo @zdvorak - We would like to follow up. Do you have any updates on this?
Thanks.

@jaimeo @zdvorak - Any updates on this?

@jaimeo @zdvorak @lomayor - We would like to follow up on this. Do you have any updates on how we can fix broken link issue(FWLink in log file is dead)?
Thank you.

I thought we fixed that link already. I've looked up an owner for it and send them this issue again.

I've also created a PR for the other issue mentioned above (KB 2952664 being superseded).

Albert is redirecting the FWlink to windows-analytics-get-started where we've added some explanation about diagtrack.

@juanand - Thank you for submitting feedback.
From our understanding, the issue has been answered by jaimeo, zdvorak & MaratMussabekov. If you feel it hasn't been resolved please re-open this issue.
Thank you for engaging with the community here for the docs.

@officedocsbot close


icloud3_v3 Migration Peculiar

Hi there. I did a few migrations to iCloud3v3. It worked great for most. On one installation, having a weird issue.
The configuration migration pulls in an out of date, old iCloud password. I update it. I then get a prompt for 2 factor code. I put that in. I get a 'unknown error occurred'. I restart home assistant then the account with the old password is then recovered, same results. I tried removing the configuration.yaml parameters and the old ic3 yaml, and reinstalling the icloud3v3.

Can I somehow reset this to start over again?
Where would the information be cached so I can remove it?
Is there a known issue or something obvious I am missing when the 2 factor code is causing an 'unknown error'?

The iCloud3 parameters are in the  config/core/.storage/icloud3/configuration file. I would go to the
Configuration Wizard > Data Sources screen and uncheck  the iCloud data source, remove the username and password and save the configuration first. Then restart iCloud3. Then go back in and put the username and password back in, save and restart iCloud3 again.
This is not a known problem. There should be an error message in the icloud3-0.log  file. Can you look for it and email the file to<EMAIL_ADDRESS>so I can see what is going on.

Thanks. I wiped the /.storage/icloud3/ folder and removed the entries from configuration.yaml. I am not sure if the FmF previous setup was causing the issue or not. The log simply said logged in was successful, which I found odd with how it was behaving.
Family share is up and working great, FmF, as known, not so much.


Let's hardwire default paths to Gaia.

#748 builds Gaia binaries into builds/gaia.  If BINARY_PATH and NODE_BINARY_PATH aren't set then let's have Voyager look for them there, or even better let's hardwire the paths and get rid of BINARY_PATH and NODE_BINARY_PATH.

Do we want devs to be able to overwrite the paths for some reasons?
David Braun<EMAIL_ADDRESS>schrieb am Fr., 1. Juni 2018, 21:34:

#748 https://github.com/cosmos/voyager/pull/748 builds Gaia binaries
into builds/gaia. If BINARY_PATH and NODE_BINARY_PATH aren't set then
let's have Voyager look for them there, or even better let's hardwire the
paths and get rid of BINARY_PATH and NODE_BINARY_PATH.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/cosmos/voyager/issues/784, or mute the thread
https://github.com/notifications/unsubscribe-auth/AFmO2Y8LoBfnTWkw4_JTBEd1Air30ZQDks5t4ZdVgaJpZM4UXNTD
.

I can't think of a reason.  If a dev wants to use a different version of Gaia then he could specify a different version to be built.

The fewer configuration flags the better, I support this idea.

i'd like us to revisit this!

What do you mean? What do you propose?

to run voyager i have to use this command:
BINARY_PATH=builds/Gaia/darwin_amd64/gaiacli NODE_BINARY_PATH=builds/Gaia/darwin_amd64/gaiad yarn testnet

but i'd like to be able to use this command:
yarn testnet

i think we're defaulting to local gaia instead of the gaia we're building with yarn build:gaia.

I thought this was w regard to letting the default gaia path point to the app-specific build, but still allowing setting the path explicitly for the scenario @faboweb outlined

Then I got this wrong. Let's do it like that. :) Thank you for clarifying.
billy rennekamp<EMAIL_ADDRESS>schrieb am Do., 12. Juli 2018,
13:36:

I thought this was w regard to letting the default gaia path point to the
app-specific build, but still allowing setting the path explicitly for the
scenario @faboweb https://github.com/faboweb outlined
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/cosmos/voyager/issues/784#issuecomment-404482529, or mute
the thread
https://github.com/notifications/unsubscribe-auth/AFmO2csd6Z4vCAabF5qUuQcRGqzUxyKwks5uFzSugaJpZM4UXNTD
.


weird interaction with gamepad button and game_restart

For some reason I don't understand when I use this code, my game restarts fine:
if(gamepad_button_check_pressed(0,gp_face4)){
game_restart();
}
If all I change is this, it does not work fine and seems to do an infinite loop of restarting (as I can tell from the output window) and my game window is stuck and doesn't seem to be actually restarting infinitely at super speed  or anything, just frozen.
if(input_check_pressed("special")){
game_restart();
}
all other gamepad inputs such as moving and firing and everything work fine with the input_check type code like for example right before this I have: (and it works fine)
if(input_check_pressed("cancel")){
game_end();
}

https://tabularelf.com/custom-game-restart/

even though the builtin function is bad news this is still a bug so we'll look into it


Install golangci-lint by binary release

golangci-lint developer says: Please, do not install golangci-lint by go get
https://github.com/golangci/golangci-lint#go-get
So, use binary instead of go get

LGTM !


Github merge_group is missing

Hi, would it be possible to get support for the merge_group event to avoid using @RawEvent?

Hey!
It would need to be added here first: https://github.com/hub4j/github-api/blob/main/src/main/java/org/kohsuke/github/GHEventPayload.java .
I'm pretty full at the moment so if you have time you could experiment with it?
If not, I'll put in on my list but probably won't get to it before mid-October.

I will take a look at hub4j and try to figure out what needs to be done there. Just need to rewire my brain from Kotlin to Java😄
Closing this issue for now. Will create a new one depending on what I'm able to do with hub4j

We can keep it open. Let me know how it goes for you and I’ll keep on my TODO if you don’t beat me to it.

That being said, if you can get me an example payload, I might be able to check if it’s a matter of a few minutes or more.