Тесты в VMware

Всем привет!
Написал код для проверки запуска под вирт.машиной и песочницей Sandboxie,
но не могу проверить его работу именно под VMware, т.к. у меня только VirtualBox.
Если у кого есть варя с Win, буду благодарен за тест. Интересует, какое железо обнаружится.
В скрепке asm и exe - вот что дампит код на моей машине VBox:

 

VMware 17.6.1 build-24319023

Код (Text):

1. CPU name string.....: AMD Ryzen 5 7500F 6-Core Processor
2. CPU cores...........: 2
3. CPU frequency.......: 3527.0 MHz
4. Physical memory.....: 2046.5 Mb
5. Check 1 sec delay...: 1000.0 msec
6. Computer name.......: DESKTOP-VALL98E
7. Display device......: VMware SVGA 3D. 1718 x 928
8. Bios Version........:
9. CD/DVDROM  name.....: NECVMWar VMware SATA CD01
10. Hard drive name.....: VMware Virtual NVMe Disk
11. Hard drive size.....: 60.0 Gb
12. NIC MAC address.....: 00:0c:29:87:26:a4
13.                        --------
14.                        08:00:27: <----- VBox   v5.2
15.                        00:21:f6:               v3.3
16.                        52:54:00:               Vagrant or QEMU
17.                        --------
18.                        00:50:56: <----- VMware Workstation
19.                        00:0c:29:               ESXi Host
20.                        00:05:69:               ESXi,GSX
21.                        00:1c:14:               VMware
22. VBox \System32 dll..:
23. Sandboxie dll test..:
24. Sandboxie Desktop...:

 

shanya0xff, спасибо!
Это мне и нужно было узнать.

 

shanya0xff, и ещё..
в папке Win\system32 вирт.машины должны быть её библиотеки
например в VBox все они начинаются с префикса VBox***.dll (см.мой скрин выше)
на VMware так-же или нет? по какому префиксу можно их найти и перечислить?

 

https://github.com/kernelwernel/VMAware
мож будя интересно

 

Думаю гонять овер 100 тестов не имеет смысла - вполне хватит и парочки.
Например как выяснилось, Sleep() на вирт.машине возвращает точно переданный нами параметр (у меня это 1000=1 сек), хотя на реальной машине по любому будет погрешность +/- 1%.

 

> хотя на реальной машине по любому будет погрешность +/- 1%.

Разрешение GTC не менее 50ms. Причем оно нелинейно. Используйте ntqueryperformancecounter для точных замеров времени.

 

так в данном случае наоборот точный qpc не нужен - в этом и суть.
вм перехватывает Sleep() и возвращает всегда значение параметра, а не реальное.

 

Код (C++):

1. #include <iostream>
2. #include <windows.h>
3. #include <winternl.h>
4. #include <chrono>
5. #include <thread>
6.  
7. // Definition of NtQueryPerformanceCounter function type
8. typedef NTSTATUS(NTAPI* PFN_NT_QUERY_PERFORMANCE_COUNTER)(
9.     PLARGE_INTEGER PerformanceCounter,
10.     PLARGE_INTEGER PerformanceFrequency OPTIONAL
11.     );
12.  
13. int main() {
14.     // Load ntdll.dll library
15.     HMODULE ntdllModule = GetModuleHandleA("ntdll.dll");
16.     if (!ntdllModule) {
17.         std::cerr << "Failed to load ntdll.dll" << std::endl;
18.         return 1;
19.     }
20.  
21.     // Get NtQueryPerformanceCounter function address
22.     PFN_NT_QUERY_PERFORMANCE_COUNTER NtQueryPerformanceCounter =
23.         (PFN_NT_QUERY_PERFORMANCE_COUNTER)GetProcAddress(ntdllModule, "NtQueryPerformanceCounter");
24.  
25.     if (!NtQueryPerformanceCounter) {
26.         std::cerr << "Failed to find NtQueryPerformanceCounter function" << std::endl;
27.         return 1;
28.     }
29.  
30.     // Get performance counter frequency
31.     LARGE_INTEGER frequency = { 0 };
32.     LARGE_INTEGER dummy = { 0 };
33.     NTSTATUS status = NtQueryPerformanceCounter(&dummy, &frequency);
34.  
35.     if (!NT_SUCCESS(status)) {
36.         std::cerr << "Error getting counter frequency. Status: 0x" << std::hex << status << std::endl;
37.  
38.         // Try fallback to QueryPerformanceFrequency
39.         if (!QueryPerformanceFrequency(&frequency)) {
40.             std::cerr << "QueryPerformanceFrequency also failed. Error: " << GetLastError() << std::endl;
41.             return 1;
42.         }
43.         std::cout << "Using QueryPerformanceFrequency instead." << std::endl;
44.     }
45.  
46.     std::cout << "Counter frequency: " << frequency.QuadPart << " Hz" << std::endl;
47.  
48.     // Time measurement example
49.     LARGE_INTEGER startCounter, endCounter;
50.  
51.     // Start time
52.     status = NtQueryPerformanceCounter(&startCounter, NULL);
53.     if (!NT_SUCCESS(status)) {
54.         std::cerr << "Error getting initial counter value. Status: 0x" << std::hex << status << std::endl;
55.         return 1;
56.     }
57.  
58.     // Execution of operation to be measured
59.     // In this case, just wait for 100 ms
60.     std::this_thread::sleep_for(std::chrono::milliseconds(100));
61.  
62.     // End time
63.     status = NtQueryPerformanceCounter(&endCounter, NULL);
64.     if (!NT_SUCCESS(status)) {
65.         std::cerr << "Error getting final counter value. Status: 0x" << std::hex << status << std::endl;
66.         return 1;
67.     }
68.  
69.     // Calculate time in milliseconds
70.     double elapsedMilliseconds =
71.         static_cast<double>(endCounter.QuadPart - startCounter.QuadPart) * 1000.0 /
72.         static_cast<double>(frequency.QuadPart);
73.  
74.     std::cout << "Time elapsed: " << elapsedMilliseconds << " ms" << std::endl;
75.  
76.     // Demonstration of non-linear measurements
77.     std::cout << "Demonstration of non-linear time intervals:" << std::endl;
78.  
79.     for (int i = 0; i < 5; i++) {
80.         LARGE_INTEGER start, end;
81.         status = NtQueryPerformanceCounter(&start, NULL);
82.         if (!NT_SUCCESS(status)) {
83.             std::cerr << "Error in iteration " << i << ". Status: 0x" << std::hex << status << std::endl;
84.             continue;
85.         }
86.  
87.         // Increase sleep interval with each iteration
88.         std::this_thread::sleep_for(std::chrono::milliseconds(50 + i * 25));
89.  
90.         status = NtQueryPerformanceCounter(&end, NULL);
91.         if (!NT_SUCCESS(status)) {
92.             std::cerr << "Error in iteration " << i << ". Status: 0x" << std::hex << status << std::endl;
93.             continue;
94.         }
95.  
96.         double elapsed =
97.             static_cast<double>(end.QuadPart - start.QuadPart) * 1000.0 /
98.             static_cast<double>(frequency.QuadPart);
99.  
100.         std::cout << "Interval " << i + 1 << ": requested "
101.             << (50 + i * 25) << " ms, measured " << elapsed << " ms" << std::endl;
102.     }
103.  
104.     return 0;
105. }

Код (C++):

1. #include <iostream>
2. #include <windows.h>
3. #include <winternl.h>
4. #include <vector>
5. #include <algorithm>
6. #include <cmath>
7. #include <iomanip>
8.  
9. // Definition of NtQueryPerformanceCounter function type
10. typedef NTSTATUS(NTAPI* PFN_NT_QUERY_PERFORMANCE_COUNTER)(
11.     PLARGE_INTEGER PerformanceCounter,
12.     PLARGE_INTEGER PerformanceFrequency OPTIONAL
13. );
14.  
15. // Structure to hold measurement statistics
16. struct MeasurementStats {
17.     double min;
18.     double max;
19.     double avg;
20.     double stdDev;
21. };
22.  
23. // Function to calculate statistics from a vector of measurements
24. MeasurementStats calculateStats(const std::vector<double>& measurements) {
25.     MeasurementStats stats = {0};
26.    
27.     if (measurements.empty()) {
28.         return stats;
29.     }
30.    
31.     stats.min = *std::min_element(measurements.begin(), measurements.end());
32.     stats.max = *std::max_element(measurements.begin(), measurements.end());
33.    
34.     // Calculate average
35.     double sum = 0.0;
36.     for (const auto& val : measurements) {
37.         sum += val;
38.     }
39.     stats.avg = sum / measurements.size();
40.    
41.     // Calculate standard deviation
42.     double sumSquaredDiff = 0.0;
43.     for (const auto& val : measurements) {
44.         double diff = val - stats.avg;
45.         sumSquaredDiff += diff * diff;
46.     }
47.     stats.stdDev = std::sqrt(sumSquaredDiff / measurements.size());
48.    
49.     return stats;
50. }
51.  
52. // Precise busy-wait function for short durations
53. void preciseSleep(double milliseconds, PFN_NT_QUERY_PERFORMANCE_COUNTER ntQueryPerfCounter, const LARGE_INTEGER& frequency) {
54.     LARGE_INTEGER start, current;
55.     ntQueryPerfCounter(&start, NULL);
56.    
57.     double elapsedMs = 0.0;
58.    
59.     while (elapsedMs < milliseconds) {
60.         ntQueryPerfCounter(&current, NULL);
61.         elapsedMs = static_cast<double>(current.QuadPart - start.QuadPart) * 1000.0 /
62.                    static_cast<double>(frequency.QuadPart);
63.        
64.         // For longer waits, yield to avoid CPU hogging
65.         if (milliseconds > 10.0 && elapsedMs < milliseconds - 5.0) {
66.             Sleep(1);
67.         }
68.         else {
69.             // Short yield for very precise timing
70.             YieldProcessor();
71.         }
72.     }
73. }
74.  
75. int main() {
76.     // Raise process priority for more accurate timing
77.     SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
78.    
79.     // Set thread priority to highest
80.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
81.    
82.     // Load ntdll.dll library
83.     HMODULE ntdllModule = GetModuleHandleA("ntdll.dll");
84.     if (!ntdllModule) {
85.         std::cerr << "Failed to load ntdll.dll" << std::endl;
86.         return 1;
87.     }
88.  
89.     // Get NtQueryPerformanceCounter function address
90.     PFN_NT_QUERY_PERFORMANCE_COUNTER NtQueryPerformanceCounter =
91.         (PFN_NT_QUERY_PERFORMANCE_COUNTER)GetProcAddress(ntdllModule, "NtQueryPerformanceCounter");
92.    
93.     if (!NtQueryPerformanceCounter) {
94.         std::cerr << "Failed to find NtQueryPerformanceCounter function" << std::endl;
95.         return 1;
96.     }
97.  
98.     // Get performance counter frequency
99.     LARGE_INTEGER frequency = {0};
100.     LARGE_INTEGER dummy = {0};
101.     NTSTATUS status = NtQueryPerformanceCounter(&dummy, &frequency);
102.    
103.     if (!NT_SUCCESS(status)) {
104.         std::cerr << "Error getting counter frequency. Status: 0x" << std::hex << status << std::endl;
105.        
106.         // Try fallback to QueryPerformanceFrequency
107.         if (!QueryPerformanceFrequency(&frequency)) {
108.             std::cerr << "QueryPerformanceFrequency also failed. Error: " << GetLastError() << std::endl;
109.             return 1;
110.         }
111.         std::cout << "Using QueryPerformanceFrequency instead." << std::endl;
112.     }
113.    
114.     std::cout << "Counter frequency: " << frequency.QuadPart << " Hz" << std::endl;
115.    
116.     // Warmup phase to stabilize CPU state
117.     std::cout << "Performing warmup..." << std::endl;
118.     for (int i = 0; i < 10; i++) {
119.         LARGE_INTEGER start, end;
120.         NtQueryPerformanceCounter(&start, NULL);
121.         preciseSleep(20, NtQueryPerformanceCounter, frequency);
122.         NtQueryPerformanceCounter(&end, NULL);
123.     }
124.    
125.     // Test intervals in milliseconds
126.     const int numIntervals = 10;
127.     const int intervalsMs[numIntervals] = {10, 20, 30, 40, 50, 75, 100, 125, 150, 200};
128.    
129.     // Number of iterations per interval for statistical significance
130.     const int iterations = 20;
131.    
132.     std::cout << "\nPrecise timing measurements:\n" << std::endl;
133.     std::cout << std::left << std::setw(12) << "Requested"
134.               << std::setw(12) << "Min"
135.               << std::setw(12) << "Max"
136.               << std::setw(12) << "Average"
137.               << std::setw(12) << "StdDev"
138.               << std::setw(12) << "Error %" << std::endl;
139.     std::cout << std::string(72, '-') << std::endl;
140.    
141.     for (int i = 0; i < numIntervals; i++) {
142.         int targetMs = intervalsMs[i];
143.         std::vector<double> measurements;
144.        
145.         for (int j = 0; j < iterations; j++) {
146.             LARGE_INTEGER start, end;
147.            
148.             status = NtQueryPerformanceCounter(&start, NULL);
149.             if (!NT_SUCCESS(status)) {
150.                 std::cerr << "Error getting start time. Status: 0x" << std::hex << status << std::endl;
151.                 continue;
152.             }
153.            
154.             // Use precise busy-wait for timing
155.             preciseSleep(targetMs, NtQueryPerformanceCounter, frequency);
156.            
157.             status = NtQueryPerformanceCounter(&end, NULL);
158.             if (!NT_SUCCESS(status)) {
159.                 std::cerr << "Error getting end time. Status: 0x" << std::hex << status << std::endl;
160.                 continue;
161.             }
162.            
163.             double elapsed = static_cast<double>(end.QuadPart - start.QuadPart) * 1000.0 /
164.                             static_cast<double>(frequency.QuadPart);
165.            
166.             measurements.push_back(elapsed);
167.         }
168.        
169.         // Calculate statistics
170.         MeasurementStats stats = calculateStats(measurements);
171.         double errorPercent = ((stats.avg - targetMs) / targetMs) * 100.0;
172.        
173.         // Print results with proper formatting
174.         std::cout << std::fixed << std::setprecision(3);
175.         std::cout << std::left << std::setw(12) << targetMs
176.                   << std::setw(12) << stats.min
177.                   << std::setw(12) << stats.max
178.                   << std::setw(12) << stats.avg
179.                   << std::setw(12) << stats.stdDev
180.                   << std::setw(12) << errorPercent << "%" << std::endl;
181.     }
182.    
183.     return 0;
184. }

рил

Counter frequency: 10000000 Hz
Time elapsed: 108.429 ms
Demonstration of non-linear time intervals:
Interval 1: requested 50 ms, measured 61.0943 ms
Interval 2: requested 75 ms, measured 79.2942 ms
Interval 3: requested 100 ms, measured 108.687 ms
Interval 4: requested 125 ms, measured 134.471 ms
Interval 5: requested 150 ms, measured 151.704 ms

 

galenkane

Эти периоды порядка планирования( те свапконтексты). Можно поднять частоту, либо нужно большее число итераций.)