Загрузка...

Скрипт Стрессер ОЗУ и ЦПУ на с++

Тема в разделе C/C++ создана пользователем rasez 13 июн 2025 в 01:01. 92 просмотра

  1. rasez
    Скопировать BBCode
    rasez Автор темы 13 июн 2025 в 01:01 Ищу ворк dm: https://t.me/N0S3NSE 218 29 апр 2025
    пиздец как же все сложно я вахуе
    наебенил вместе с гпт и руками какой то типо стрессер(изучал памятьи тп)
    ПИДЗЕЦ ПОЛНЫЙ​
    C
    #include <windows.h>
    
#include <thread>
    
#include <atomic>
    
#include <vector>
    
#include <chrono>
    
#include <cstring>
    

    
HWND hwndCpu, hwndMem, hwndStart, hwndStop;
    
std::atomic<bool> running(false);
    
std::atomic<bool> stressCpu(false);
    
std::atomic<bool> stressMem(false);
    
std::vector<std::thread> stressThreads;
    

    
const int CPU_THREADS = 8;     
    
const int MEM_THREADS = 8;     
    
const size_t BLOCK_SIZE = 50 * 1024 * 1024;
    

    
void CpuStressFunc()
    
{
    
    while (running.load())
    
    {
    
        auto start = std::chrono::high_resolution_clock::now();
    

    
      
    
        while (true)
    
        {
    
            auto now = std::chrono::high_resolution_clock::now();
    
            auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count();
    
            if (elapsedMs >= 20) break;
    
            for (volatile int i = 0; i < 100000; ++i) {} 
    
        }
    
        std::this_thread::sleep_for(std::chrono::milliseconds(0));
    
    }
    
}
    

    
void MemStressFunc()
    
{
    
    std::vector<char*> blocks;
    
    try
    
    {
    
        while (running.load())
    
        {
    
          
    
            for (int i = 0; i < 100 && running.load(); ++i)
    
            {
    
                char* block = new char[BLOCK_SIZE];
    
                memset(block, 1, BLOCK_SIZE);
    
                blocks.push_back(block);
    
            }
    
            
    
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
    
        }
    
    }
    
    catch (std::bad_alloc&)
    
    {
    
        
    
    }
    

    

    
    for (auto b : blocks)
    
        delete[] b;
    
}
    

    
void StartStress()
    
{
    
    running.store(true);
    
    stressThreads.clear();
    

    
    if (stressCpu.load())
    
    {
    
        for (int i = 0; i < CPU_THREADS; ++i)
    
            stressThreads.emplace_back(CpuStressFunc);
    
    }
    
    if (stressMem.load())
    
    {
    
        for (int i = 0; i < MEM_THREADS; ++i)
    
            stressThreads.emplace_back(MemStressFunc);
    
    }
    
}
    

    
void StopStress()
    
{
    
    running.store(false);
    
    for (auto& t : stressThreads)
    
        if (t.joinable())
    
            t.join();
    
    stressThreads.clear();
    
}
    

    
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
    
{
    
    switch (msg)
    
    {
    
    case WM_CREATE:
    
        hwndCpu = CreateWindow(L"BUTTON", L"Стресс CPU", WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON,
    
            20, 20, 100, 25, hwnd, (HMENU)1, nullptr, nullptr);
    
        hwndMem = CreateWindow(L"BUTTON", L"Стресс памяти", WS_VISIBLE | WS_CHILD | BS_AUTORADIOBUTTON,
    
            150, 20, 120, 25, hwnd, (HMENU)2, nullptr, nullptr);
    

    
        hwndStart = CreateWindow(L"BUTTON", L"Старт", WS_VISIBLE | WS_CHILD,
    
            40, 70, 80, 30, hwnd, (HMENU)3, nullptr, nullptr);
    
        hwndStop = CreateWindow(L"BUTTON", L"Стоп", WS_VISIBLE | WS_CHILD | WS_DISABLED,
    
            160, 70, 80, 30, hwnd, (HMENU)4, nullptr, nullptr);
    

    
        SendMessage(hwndCpu, BM_SETCHECK, BST_CHECKED, 0);
    
        stressCpu = true;
    
        stressMem = false;
    
        break;
    

    
    case WM_COMMAND:
    
        switch (LOWORD(wParam))
    
        {
    
        case 1: // CPU selected
    
            stressCpu = true;
    
            stressMem = false;
    
            SendMessage(hwndCpu, BM_SETCHECK, BST_CHECKED, 0);
    
            SendMessage(hwndMem, BM_SETCHECK, BST_UNCHECKED, 0);
    
            break;
    

    
        case 2: // Memory selected
    
            stressCpu = false;
    
            stressMem = true;
    
            SendMessage(hwndCpu, BM_SETCHECK, BST_UNCHECKED, 0);
    
            SendMessage(hwndMem, BM_SETCHECK, BST_CHECKED, 0);
    
            break;
    

    
        case 3: // Start
    
            if (!running.load())
    
            {
    
                StartStress();
    
                EnableWindow(hwndStart, FALSE);
    
                EnableWindow(hwndStop, TRUE);
    
                EnableWindow(hwndCpu, FALSE);
    
                EnableWindow(hwndMem, FALSE);
    
            }
    
            break;
    

    
        case 4: // Stop
    
            if (running.load())
    
            {
    
                StopStress();
    
                EnableWindow(hwndStart, TRUE);
    
                EnableWindow(hwndStop, FALSE);
    
                EnableWindow(hwndCpu, TRUE);
    
                EnableWindow(hwndMem, TRUE);
    
            }
    
            break;
    
        }
    
        break;
    

    
    case WM_DESTROY:
    
        StopStress();
    
        PostQuitMessage(0);
    
        break;
    

    
    default:
    
        return DefWindowProc(hwnd, msg, wParam, lParam);
    
    }
    
    return 0;
    
}
    

    
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int nCmdShow)
    
{
    
    WNDCLASS wc = {};
    
    wc.lpfnWndProc = WndProc;
    
    wc.hInstance = hInstance;
    
    wc.lpszClassName = L"SimpleStresserClass";
    
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    

    
    if (!RegisterClass(&wc))
    
        return 0;
    

    
    HWND hwnd = CreateWindow(wc.lpszClassName, L"Жёсткий стрессер",
    
        WS_OVERLAPPEDWINDOW & ~(WS_THICKFRAME | WS_MAXIMIZEBOX),
    
        CW_USEDEFAULT, CW_USEDEFAULT, 300, 180,
    
        nullptr, nullptr, hInstance, nullptr);
    

    
    if (!hwnd)
    
        return 0;
    

    
    ShowWindow(hwnd, nCmdShow);
    
    UpdateWindow(hwnd);
    

    
    MSG msg{};
    
    while (GetMessage(&msg, nullptr, 0, 0))
    
    {
    
        TranslateMessage(&msg);
    
        DispatchMessage(&msg);
    
    }
    

    
    return 0;
    
}
    типа во [IMG] [IMG]
     
    13 июн 2025 в 01:01
Загрузка...
Top