ФунцияПотока(объём_памяти)
{
указатель_на_сегмент=ВыделитьПамять(объём_памяти);
ОсвободитьПамять(указатель_на_сегмент);
}
как с помощью потока захватить, а потом освободить оперативную память
#include <cstdlib>
#include <iostream>
#include <windows.h>
using namespace std;
#define N 128
#define M 256
#define K 512
DWORD WINAPI ThreadFunc(PVOID pParam)
{
DWORD dwResult=0;
return dwResult;
}
DWORD WINAPI ThreadFunc2(PVOID pParam)
{
DWORD dwResult=0;
return dwResult;
}
DWORD WINAPI ThreadFunc3(PVOID pParam)
{
DWORD dwResult=0;
return dwResult;
}
int main()
{
byte *p, *q, *e;
__int64 c1, c2, fr;
LPDWORD ID;
HANDLE hThread1, hThread2, hThread3;
DWORD dwResult=0;
int i,u,j;
setlocale(LC_ALL,"Russian");
for (i=0; i<10; i++)
{
QueryPerformanceCounter((LARGE_INTEGER *)&c1);
hThread1=CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, (LPDWORD)&ID);
p=(byte*)GlobalAlloc(GPTR,N);
GlobalFree(p);
QueryPerformanceCounter((LARGE_INTEGER *)&c2);
QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
CloseHandle(hThread1);
cout << "Размер:"<< N << " Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////////
QueryPerformanceCounter((LARGE_INTEGER *)&c1);
hThread2=CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadFunc2, NULL, 0, (LPDWORD)&ID);
q=(byte*)GlobalAlloc(GPTR,M);
GlobalFree(q);
QueryPerformanceCounter((LARGE_INTEGER *)&c2);
QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
CloseHandle(hThread2);
cout << "Размер: 256 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
////////////////////////////////////////////////////////////////////////////////////////////////////////
QueryPerformanceCounter((LARGE_INTEGER *)&c1);
hThread3=CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadFunc3, NULL, 0, (LPDWORD)&ID);
e=(byte*)GlobalAlloc(GPTR,K);
GlobalFree(e);
QueryPerformanceCounter((LARGE_INTEGER *)&c2);
QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
CloseHandle(hThread3);
cout << "Размер: 512 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
}
TerminateThread( hThread1, dwResult);
TerminateThread( hThread2, dwResult);
TerminateThread( hThread3, dwResult);
cin.get();
return 0;
}
я захватил память с помощью функции GlobalAlloc, нужно это сделать потоком, а как не знаю, возможно еще где-то накосячил ...
вот задание целиком:
Последовательно запустить 3 потока. Первый поток захватывает, а затем освобождает 128К оперативной памяти. Второй - 256К. Третий – 512К. Измерить время исполнения каждого из потоков. Измерения повторить 10 раз.
Предположу, что время везде будет одинаково.
DWORD WINAPI ThreadFunc(PVOID pParam)
{
DWORD dwTlsIndex = TlsAlloc();
TlsSetValue(dwTlsIndex,GlobalAlloc(GPTR,N));
DWORD dwResult=0;
return dwResult;
}
DWORD WINAPI ThreadFunc(PVOID pParam)
{
DWORD dwTlsIndex = TlsAlloc();
TlsSetValue(dwTlsIndex,(byte*)GlobalAlloc(GPTR,N));
GlobalFree(TlsSetValue);
DWORD dwResult=0;
return dwResult;
}
верно????
Кстати, если нет никаких особых причин использовать GlobalAlloc, то рекомендую использовать HeapAlloc/HeapFree.
TlsSetValue так не работает. Эта функция тут вообще не нужна.
Спасибо за рекомендацию, так и поступлю, я ещё учусь программировать и поэтому получаются такие извращения))если не трудно покажите пожалуйста как можно было без них обойтись...
и у меня есть подозрения, что можно было не писать 3 раза почти одинаковые функции потока, а вместо этого сделать цикл, ведь память которую мы выделяем каждый раз увеличивается на 2 или тогда просто получится разная интерпритация функции
Код:
DWORD WINAPI ThreadFunc(N)
{
DWORD dwSegment=HeapAlloc(N);
HeapFree(dwSegment);
}
Возможно, стоит обратиться к документации или
спасибо, буду разбираться
Код:
CloseHandle(hThread3); // тут закрываешь указатель на поток
cout << "Размер: 512 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
}
TerminateThread( hThread1, dwResult);
TerminateThread( hThread2, dwResult);
TerminateThread( hThread3, dwResult); // здесь аварийно завершаешь поток который был удалён
cout << "Размер: 512 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
}
TerminateThread( hThread1, dwResult);
TerminateThread( hThread2, dwResult);
TerminateThread( hThread3, dwResult); // здесь аварийно завершаешь поток который был удалён
И самое главное при работающем потоке невозможно удалить указатель функцией CloseHandle.
Для этого нужно завершить поток функцией ExitThread или TerminateThread, TerminateThread
не подвешивает то есть работает асинхронно нужен WaitForSingleObject. Короче каша одна у тебя здесь.
Для захвата памяти используй VirtualAlloc, HeapAlloc это куча.
#include <cstdlib>
#include <iostream>
#include <windows.h>
using namespace std;
#define N 128
#define M 256
#define K 512
DWORD WINAPI ThreadFunc(PVOID pParam)
{
byte* pN=(byte*)HeapAlloc(pN,0,N);
HeapFree(pN,0,pParam);
DWORD dwResult=0;
return dwResult;
}
DWORD WINAPI ThreadFunc2(PVOID pParam)
{
byte* pM=(byte*)HeapAlloc(pM,0,M);
HeapFree(pM,0,pParam);
DWORD dwResult=0;
return dwResult;
}
DWORD WINAPI ThreadFunc3(PVOID pParam)
{
byte* pK=(byte*)HeapAlloc(pK,0,K);
HeapFree(pK,0,pParam);
DWORD dwResult=0;
return dwResult;
}
int main()
{
__int64 c1, c2, fr;
LPDWORD ID;
HANDLE hThread1, hThread2, hThread3;
DWORD dwResult=0;
int i,u,j;
setlocale(LC_ALL,"Russian");
for (i=0; i<10; i++)
{
QueryPerformanceCounter((LARGE_INTEGER *)&c1);
hThread1=CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, (LPDWORD)&ID);
QueryPerformanceCounter((LARGE_INTEGER *)&c2);
QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
TerminateThread( hThread1, dwResult);
cout << "Размер: 128 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////////
QueryPerformanceCounter((LARGE_INTEGER *)&c1);
hThread2=CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadFunc2, NULL, 0, (LPDWORD)&ID);
QueryPerformanceCounter((LARGE_INTEGER *)&c2);
QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
TerminateThread( hThread2, dwResult);
cout << "Размер: 256 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
////////////////////////////////////////////////////////////////////////////////////////////////////////
QueryPerformanceCounter((LARGE_INTEGER *)&c1);
hThread3=CreateThread(NULL,0, (LPTHREAD_START_ROUTINE)ThreadFunc3, NULL, 0, (LPDWORD)&ID);
QueryPerformanceCounter((LARGE_INTEGER *)&c2);
QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
TerminateThread( hThread3, dwResult);
cout << "Размер: 512 Время"<< i << ": " << (c2-c1)/(float)fr << endl<<endl;
}
WaitForSingleObject(hThread1,100);
WaitForSingleObject(hThread2,100);
WaitForSingleObject(hThread3,100);
cin.get();
return 0;
}
Три отдельных функции, выполняющих одно и то же - плохо. Достаточно одной.
Делать три раза define вместо изменения одного значения в цикле - плохо.
Вызов WaitForSingleObject не нужен вообще.
Handle каждого потока должен быть закрыт через CloseHandle.
Но, если всё и так работает, нужно ли это исправлять? Замеры же производятся.
xAtom
"Удалить" "указатель" ещё как можно и даже нужно. Во-первых, если закрыть описатель до вызова TerminateThread, то поток уже невозможно будет остановить таким способом. Во-вторых, в документации написано: terminating a thread does not necessarily remove the thread object from the system. A thread object is deleted when the last thread handle is closed.
спасибо, теперь всё понятно)