Загрузка процессора через именованный канал

// Client.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include "..\IFace.h"
//Основной объект для работы с именованным каналом на клиенте
class NPSimpleClient
{
public:
NPSimpleClient(LPCTSTR pName):name(pName){}
//Ожидание подключения к именованному каналу сервера
void Wait(DWORD dwTimeOut=NMPWAIT_WAIT_FOREVER)
{
if(!WaitNamedPipe(name.c_str(),dwTimeOut))
throw _T("WaitNamedPipe");
}
//Передача запроса серверу и получение ответа
RESPONSE Call(REQUEST& req)
{
RESPONSE res;
DWORD dwRead;
if(!CallNamedPipe(name.c_str(),&req,
sizeof(req), &res,sizeof(res), &dwRead,
NMPWAIT_WAIT_FOREVER))
throw _T("CallNamedPipe");
return res;
}
protected:
_tstring name;
};
int _tmain (int argc, LPTSTR argv [])
{
//Подключиться к каналу на сервере с именем, передаваемым в
//качестве параметра.
//Если параметр отсутствует, то подключиться к текущему
//компьютеру.
TCHAR NamePipe[128];
_stprintf_s(NamePipe,sizeof(NamePipe)/sizeof(TCHAR),
_T("\\\\%s\\PIPE\\TASK_SRV"),(argc==2)
?argv[1]:_T("."));
NPSimpleClient client(NamePipe);
try
{
while(true)
{
//Ожидание подключения к серверу
client.Wait();
//Цикл передачи запроса и получения ответа от сервера
TCHAR text[128];
_tcout<<_T("\nNPClient> ");
_getts_s(text,sizeof(text)/sizeof(TCHAR));
if(_tcsicoll(text,_T("Quit"))==0)
break;
REQUEST req(text);
RESPONSE res=client.Call(req);
_tcout<<res.text;
}
return 0;
}
catch(LPCTSTR text)
{
return PrintError(text);
}
}

#include "stdafx.h"
#include "..\IFace.h"
//Включаем для поддержки контейнера
#include <vector>
//Включаем для поддержки поиска элемента в контейнере
#include <algorithm>
//Основной объект для работы с именованным каналом на сервере
class NPServer
{
public:
NPServer(LPCTSTR pName):
//Создаем именованный канал с именем pName:
//Двунаправленный канал PIPE_ACCESS_DUPLEX
//Тип передачи данных - поток сообщений:
//PIPE_READMODE_MESSAGE | PIPE_TYPE_MESSAGE
//Синхронный способ передачи данных PIPE_WAIT
//Поддерживать на создаваемом канале только одно
// приложение однопоточный сервер)
//Использовать входной и выходной буфер размером по
//умолчанию.
//Ожидать подключение к каналу бесконечно
//Установить атрибуты безопасности по умолчанию
hPipe(CreateNamedPipe(pName, PIPE_ACCESS_DUPLEX,
PIPE_READMODE_MESSAGE | PIPE_TYPE_MESSAGE |
PIPE_WAIT, 1, 0, 0, INFINITE, NULL)){}
~NPServer()
{
//Освобождение канала
if(hPipe!=INVALID_HANDLE_VALUE)
CloseHandle(hPipe);
}
//Ожидание запроса от клиента
REQUEST getRequest(void)
{
//Синхронное (см. второй параметр
//ConnectNamedPipe)
//ожидание подключения клиента
if(!ConnectNamedPipe(hPipe,NULL))
throw _T("ConnectNamedPipe");
REQUEST req;
DWORD nRead;
//Синхронное получение данных от клиента
if(!ReadFile (hPipe, &req, sizeof(req), &nRead,
NULL))
_tcout<<_T("Read from named pipe failed\n");
return req;
}
//Отправление ответа клиенту и отключение от него
void putResponse(RESPONSE& res)
{
DWORD nWrite;
//Синхронная передача данных ожидающему клиенту
if(!WriteFile (hPipe, &res, sizeof(res),
&nWrite, NULL))
_tcout<<_T("Write to named pipe failed\n");
//Отключение клиента от канала
if(!DisconnectNamedPipe(hPipe))
throw _T("DisconnectNamedPipe");
}
private:
HANDLE hPipe;
};
 
//Базовый класс для удаленных операций.
//Каждая операция характеризуется в виде строки запроса:
//"<Команда> <Параметр>"
//Метод Make проверяет относится ли строка запроса к данной
//операции и выполняет ее если это так.
//Возвращает true в случае выполнения и false - иначе
class OPER
{
public:
OPER(LPCTSTR pName=NULL) : size(lstrlen(pName)),
name(pName){}
//Метод Make реализует запрашиваемую удаленным клиентом
//операцию.
//В реализации использовна заглушка с сообщением об
//ошибке.
virtual bool Make(REQUEST& req,RESPONSE& res)
{
_sntprintf_s(res.text,sizeof(res.text)/sizeof(TCHAR),
_T("Unknown operation"));
return true;
}
protected:
//Проверка соответствия выполняемой объектом команды
//Возврат указателя на параметр команды
//(формат "<Команда> <Параметр>")
LPCTSTR Is(LPCTSTR text)
{
if(text[size]!=_T(' ') ||
_tcsnicoll(text,name,size)!=0)
return NULL;
return text+size+1;
}
UINT size;
LPCTSTR name;
//Определение контейнера задач (списка задач)
//и уникального идентификатора последней добавденной
//задачи
static vector<TASK> arr;
static UINT id;
public:
static void DebugMessage(void)
{
//Выдача отладочного сообщения о состоянии списка
//задач
UINT size=arr.size();
_tprintf(_T("\nTask list\nID |Name\n"));
 
for(UINT i=0;i<size;i++)
{
TASK& cur=arr[i];
_tprintf(_T("%5d|%s\n"),cur.id,cur.name);
}
_tprintf(_T("Total: %d\n\n"),size);
}
};
//Определение контейнера задач
//и уникального идентификатора текущей задачи
vector<TASK> OPER::arr;
UINT OPER::id=0;
//Команда вида "Add <Имя>"
//Добавление задачи с именем <Имя> в список задач
class OPER_ADD:public OPER
{
public:
OPER_ADD():OPER(_T("Add")){}
virtual bool Make(REQUEST& req,RESPONSE& res)
{
LPCTSTR name=Is(req.text);
//Если получена команда Add (добавить) то создаем
//новую задачу и добавляем ее в список
if(name)
{
TASK task(++id,name);
arr.push_back(task);
//Формирование
_sntprintf_s(res.text,sizeof(res.text) /
sizeof(TCHAR),
_T("Add item #%d"),task.id);
return true;
}
return false;
}
};
//Команда вида "Del <Идентификатор>"
//Удаление задачи с идентификатором <Идентификатор> из списка
//задач
class OPER_DEL:public OPER
{
public:
OPER_DEL():OPER(_T("Del")){}
virtual bool Make(REQUEST& req,RESPONSE& res)
{
LPCTSTR param=Is(req.text);
//Если получена команда Del (удалить)
 
//то ищем задачу с этим идентификатором
//При нахождении удаляем задачу из списка
if(param)
{
UINT id=_tstoi(param);
vector<TASK>::iterator pos=find(arr.begin(),
arr.end(),id);
if(pos==arr.end())
{
_sntprintf_s(res.text,
sizeof(res.text)/sizeof(TCHAR),
_T("#%d is not exist"),id);
}
else
{
arr.erase(pos);
_sntprintf_s(res.text,
sizeof(res.text)/sizeof(TCHAR),
_T("#%d has deleted"),id);
}
return true;
}
return false;
}
};
//Команда вида "Get <Индекс>"
//Возврат описания задачи с индексем <Индекс> из списка задач
class OPER_GET:public OPER
{
public:
OPER_GET():OPER(_T("Get")){}
virtual bool Make(REQUEST& req,RESPONSE& res)
{
    LPCTSTR param=Is(req.text);
//Если запрос Get (получить) то возвращаем описание
//задачи в виде <Идентификатор>:<Имя>
    if(param)
    {
        UINT size=arr.size();
        UINT id=_tstoi(param);
        if(id<size)
        {
            vector<TASK>::iterator pos=arr.begin()+id;
            TASK& task=arr[id];
            _sntprintf_s(res.text,sizeof(res.text)/sizeof(TCHAR),_T("%3d:%s"),task.id,task.name);
        }
        else
        {
            _sntprintf_s(res.text,sizeof(res.text)/sizeof(TCHAR),_T("Task list is containing %d records"),size);
            return true;
        }
    }
    return false;
}
 
};
//Команда вида "Help" (без параметров)
//Возврат описания поддерживающих команд
class OPER_HLP:public OPER
{
public:
OPER_HLP():OPER(_T("Help")){}
virtual bool Make(REQUEST& req,RESPONSE& res)
{
if(_tcsicoll(req.text,name)==0)
{
_tcsncpy_s(res.text,sizeof(res.text)/
sizeof(TCHAR),
_T("Add <name>\t- add new task\nDel <ID>\tdelete task\nGet <index>\t- get task by index\nCount\t\t- get size\n"),_TRUNCATE);
return true;
}
return false;
}
};
//Команда вида "Count" (без параметров)
//Возврат количества элементов в списке задач
class OPER_CNT:public OPER
{
public:
OPER_CNT():OPER(_T("Count")){}
virtual bool Make(REQUEST& req,RESPONSE& res)
{
if(_tcsicoll(req.text,name)==0)
{
_sntprintf_s(res.text,
sizeof(res.text)/sizeof(TCHAR),
_T("Task list is containing %d records"),
arr.size());
return true;
}
return false;
}
};
 
//Формирование списка команд
OPER_ADD add;
OPER_DEL del;
OPER_GET Get;
OPER_HLP hlp;
OPER_CNT cnt;
OPER def;
 
OPER* oper[]={&add,&del,&Get,&hlp,&cnt,&def};
 
 
int _tmain (int argc, LPTSTR argv [])
{
//Создать канал на текущем сервере под именем TASK_SRV
NPServer server(_T("\\\\.\\PIPE\\TASK_SRV"));
try
{
while(true)
{
#ifdef _DEBUG
OPER::DebugMessage();
#endif
//Ожидание запроса
REQUEST req=server.getRequest();
RESPONSE res;
//Перебор команд и получение ответа если команда
//поддерживается
for(UINT i=0;i<sizeof(oper)/sizeof(OPER*);i++)
{
if(oper[i]->Make(req,res))
break;
}
//Отправка ответа и отключение клиента
server.putResponse(res);
//Дублирование ответа на консоле
_tcout<<res.text<<endl;
}
return 0;
}
catch(LPCTSTR text)
{
return PrintError(text);
}
}

#include <stdio.h>
#include <locale.h>
#include <windows.h>
 
int GetCpuUsage()
{
    static ULARGE_INTEGER TimeIdle, TimeKernel, TimeUser;
    FILETIME Idle, Kernel, User;
    ULARGE_INTEGER uIdle, uKernel, uUser;
    GetSystemTimes(&Idle, &Kernel, &User);
    memcpy(&uIdle, &Idle, sizeof(FILETIME));
    memcpy(&uKernel, &Kernel, sizeof(FILETIME));
    memcpy(&uUser, &User, sizeof(FILETIME));
    long long t;
    t = (((((uKernel.QuadPart - TimeKernel.QuadPart) + (uUser.QuadPart - TimeUser.QuadPart)) -
        (uIdle.QuadPart - TimeIdle.QuadPart))*(100)) / ((uKernel.QuadPart -
            TimeKernel.QuadPart) + (uUser.QuadPart - TimeUser.QuadPart)));
    TimeIdle.QuadPart = uIdle.QuadPart;
    TimeUser.QuadPart = uUser.QuadPart;
    TimeKernel.QuadPart = uKernel.QuadPart;
    return(static_cast<int>(t));
}
 
int main(void)
{
    setlocale(LC_ALL, "Rus");
    system("mode 40, 4");
    while (!GetAsyncKeyState(VK_END))
    {
        printf("Загрузка ЦП: %2d\r", GetCpuUsage());
        Sleep(2200);/* Здесь установить по-частоте вашего процессора / 2. */
    }
    return EXIT_SUCCESS;
}