Take advantage of Multi-Core Processors and Multi-threading

[topblast]

MultiThreading is already in the programs u develop, just behind the scenes. Take advantage of it to improve the performance of those multi-core processors and optimize it for the single thread processors.

example:

#include <ppl.h>

using namespace Concurrency;

void Hook()
{
    parallel_invoke(
        [&] {
            //Hook Present
        },
        [&] {
            //Hook Endscene
        });
     );
}

This will allow u to do multiple things at a time using multiple threads.The number of threads are limited to the number of logical processor and single thread processors will not see any performance change. Something like this will help u with your menus. The reason menus lag is because of the font. Having to draw every character in every string for every item. For each character in a string, in each items, that is a lot of time wasted in looping, but what if u could do more than one of these at a time.

Example:
Please note that fonts not coded for concurrency may have rendering errors, if requested i will be willing to code a Font class for Concurrency

//This function will return the time it takes to call the function
template <class Function>
__int64 time_call(Function&& f){
   __int64 begin = GetTickCount();
   f();
   return GetTickCount() - begin;
}


void DrawParallel()
{
	parallel_for(0, 10, [&] (int i)
	{
		Font.DrawText(200, 20+ i*15, WHITE, "BLA BLA BLA");
	});
}


void DrawSerial()
{
	for(int i = 0; i < 10; i++)
	{
		Font.DrawText(20 , 20 + i*15, WHITE, "BLA BLA BLA");
	}
}


void RenderFont()
{
// Draws the time it takes to do these different Draws.
	Font.DrawNumber( 200, 10, WHITE, time_call([&] { DrawParallel(); } ));
	Font.DrawNumber( 20, 10, WHITE, time_call([&] { DrawSerial(); } ));
}

Depending on the number of logical cores the time it takes to render these times may differ.

[Deadeys]

MultiThreading is already in the programs u develop, just behind the scenes. Take advantage of it to improve the performance of those multi-core processors and optimize it for the single thread processors.

example:

#include <ppl.h>

using namespace Concurrency;

void Hook()
{
    parallel_invoke(
        [&] {
            //Hook Present
        },
        [&] {
            //Hook Endscene
        });
     );
}

This will allow u to do multiple things at a time using multiple threads.The number of threads are limited to the number of logical processor and single thread processors will not see any performance change. Something like this will help u with your menus. The reason menus lag is because of the font. Having to draw every character in every string for every item. For each character in a string, in each items, that is a lot of time wasted in looping, but what if u could do more than one of these at a time.

Example:
Please note that fonts not coded for concurrency may have rendering errors, if requested i will be willing to code a Font class for Concurrency

//This function will return the time it takes to call the function
template <class Function>
__int64 time_call(Function&& f){
   __int64 begin = GetTickCount();
   f();
   return GetTickCount() - begin;
}


void DrawParallel()
{
	parallel_for(0, 10, [&] (int i)
	{
		Font.DrawText(200, 20+ i*15, WHITE, "BLA BLA BLA");
	});
}


void DrawSerial()
{
	for(int i = 0; i < 10; i++)
	{
		Font.DrawText(20 , 20 + i*15, WHITE, "BLA BLA BLA");
	}
}


void RenderFont()
{
// Draws the time it takes to do these different Draws.
	Font.DrawNumber( 200, 10, WHITE, time_call([&] { DrawParallel(); } ));
	Font.DrawNumber( 20, 10, WHITE, time_call([&] { DrawSerial(); } ));
}

Depending on the number of logical cores the time it takes to render these times may differ.

No shit shurlock xD

[topblast]

No shit shurlock xD

So i take it your using parallelism already? in menus and all of that.

---------- Post added at 02:41 PM ---------- Previous post was at 02:38 PM ----------

I am just saying in FPS games better frames and who get the hacks in first win.

[Deadeys]

So i take it your using parallelism already? in menus and all of that.

---------- Post added at 02:41 PM ---------- Previous post was at 02:38 PM ----------

I am just saying in FPS games better frames and who get the hacks in first win.

Btw, if you need to invoke then there is not realy a big preformance boost. The part that you invoke will run on the thread who created the item. After that it will return to the thread you were running. So if you have 4 threads waiting till the other thread finished his job.. Then there is a lot of proccessing power "wasted". This doesn't mean that invoking alway's will end in preformance lost, but for some things it will.

I almost can't program good software without Multi threading. A very good tip for the peapel who want to start with Multi threading:
First make a part working in one thread, if you have done that you can use more threads to do the job faster. Why? Debugging multi threaded code is harder then debugging single threaded code.

You also need to understand locking critical parts, for example when you are sending data to a server. Then you don't want to send data at the same time.

You also need to know when Multi threading will benefit and what features your programming language has with multithreading.

Don't start with multithreading if you don't understand the concept, learn methodes en watch some videos to see how you can use it:
https://www.google.nl/url?sa=t&rct=j&...eDeq_K_S99nuXA

For the ppl who will read ops code, GetTickCount is bad practice. 1 Tick can be 60% faster on an other pc. If you want to measure time don't use this function! So don't use his time_call function.

Use this: https://www.mpgh.net/forum/242-crossf...ml#post6491415

For the rest, gj

[topblast]

Btw, if you need to invoke then there is not realy a big preformance boost. The part that you invoke will run on the thread who created the item. After that it will return to the thread you were running. So if you have 4 threads waiting till the other thread finished his job.. Then there is a lot of proccessing power "wasted". This doesn't mean that invoking alway's will end in preformance lost, but for some things it will.

I almost can't program good software without Multi threading. A very good tip for the peapel who want to start with Multi threading:
First make a part working in one thread, if you have done that you can use more threads to do the job faster. Why? Debugging multi threaded code is harder then debugging single threaded code.

You also need to understand locking critical parts, for example when you are sending data to a server. Then you don't want to send data at the same time.

You also need to know when Multi threading will benefit and what features your programming language has with multithreading.

Don't start with multithreading if you don't understand the concept, learn methodes en watch some videos to see how you can use it:
https://www.google.nl/url?sa=t&rct=j&...eDeq_K_S99nuXA

For the ppl who will read ops code, GetTickCount is bad practice. 1 Tick can be 60% faster on an other pc. If you want to measure time don't use this function! So don't use his time_call function.

Use this: https://www.mpgh.net/forum/242-crossf...ml#post6491415

For the rest, gj

if it is doing it 4 at once, it will be faster than 4 one after the other which this is not for server but for hacks, with good coding it can do well also with those while loops that are in the hacks in this section, parallel_for will help them alot.

I dont expect them to use them everywhere really, cause it will not work well. It is good to have a little Serialization

[~FALLEN~]

MultiThreading is already in the programs u develop, just behind the scenes. Take advantage of it to improve the performance of those multi-core processors and optimize it for the single thread processors.

example:

#include <ppl.h>

using namespace Concurrency;

void Hook()
{
    parallel_invoke(
        [&] {
            //Hook Present
        },
        [&] {
            //Hook Endscene
        });
     );
}

This will allow u to do multiple things at a time using multiple threads.The number of threads are limited to the number of logical processor and single thread processors will not see any performance change. Something like this will help u with your menus. The reason menus lag is because of the font. Having to draw every character in every string for every item. For each character in a string, in each items, that is a lot of time wasted in looping, but what if u could do more than one of these at a time.

Example:
Please note that fonts not coded for concurrency may have rendering errors, if requested i will be willing to code a Font class for Concurrency

//This function will return the time it takes to call the function
template <class Function>
__int64 time_call(Function&& f){
   __int64 begin = GetTickCount();
   f();
   return GetTickCount() - begin;
}


void DrawParallel()
{
	parallel_for(0, 10, [&] (int i)
	{
		Font.DrawText(200, 20+ i*15, WHITE, "BLA BLA BLA");
	});
}


void DrawSerial()
{
	for(int i = 0; i < 10; i++)
	{
		Font.DrawText(20 , 20 + i*15, WHITE, "BLA BLA BLA");
	}
}


void RenderFont()
{
// Draws the time it takes to do these different Draws.
	Font.DrawNumber( 200, 10, WHITE, time_call([&] { DrawParallel(); } ));
	Font.DrawNumber( 20, 10, WHITE, time_call([&] { DrawSerial(); } ));
}

Depending on the number of logical cores the time it takes to render these times may differ.

Nice share. Although I find it easier just to use prims to render text and you really wont notice much ( if any ) lag via prims. Have to remember that if people are running old single cores this really won't make a difference where as the prims would. And deadeys has a point with critical sections, and you might want to look into locking your pointers when they're not in use, there is tons of ways to improve performance. nevertheless, i'm glad to see someone actually having knowledge of the language xD & as i said before, nice share.

--edit--

also you guys should checkout the new standard & the conference that went along with its release. make sure you delete any allocated memory after it's done being used and cache as much data as possible, and optimize your code and such

[topblast]

Running this code to time it and Sleep for 10 ms i got the times below, u can see the difference 8 threaded processor have over the 4 threaded one when using parallelism.

#include <iostream>
#include <Windows.h>
#include <ppl.h>

template <class Function>
__int64 time_call(Function&& f){
   __int64 begin = GetTickCount();
   f();
   return GetTickCount() - begin;
}

int main(int argc, char** argv)
{
	printf("Time : %i\r\n\n",time_call([&]{

		Concurrency::parallel_for(0, 50,[&](int i)
		{
			printf("Output %i\r\n", i);
			Sleep(10);
		});
	}));
	system("pause");
	return 0;
}

Running this code to time it and Sleep for 10 ms i got the times below, there is no difference between the 8 threaded processor and the 4 threaded one when using traditional for loops, performance wasted.

#include <iostream>
#include <Windows.h>
#include <ppl.h>

template <class Function>
__int64 time_call(Function&& f){
   __int64 begin = GetTickCount();
   f();
   return GetTickCount() - begin;
}

int main(int argc, char** argv)
{
	printf("Time : %i\r\n\n",time_call([&]{
		for(int i=0; i<50;i++)
		{
			printf("Output %i\r\n", i);
			Sleep(10);
		}
	}));
	system("pause");
	return 0;
}

---------- Post added at 11:05 PM ---------- Previous post was at 10:53 PM ----------
Test for AMD Phenom II x4 (Quad Core, 4 Thread) = 125 ms vs 499ms




---------- Post added at 11:09 PM ---------- Previous post was at 11:05 PM ----------

Test for Intel CORE i7 sandybridge (Quad Core x2 threads, 8 Threads ) = 62ms ~ 78 ms vs 499ms
: This is why Intel Better, more threads in a core, so 8 logical processors, just saying

[Deadeys]

Omg, are you brains less or did't you read what I typed? You can't mesure time with GetTickCount! Intel will have an other TickCount in 1 seconde then amd. And its imposable that you have in 2 runes the same result..

And what did you test? How to print as fast as posable a messange? Use this in game when you render your menu. The game also needs threads, and if you have more threads then your system can run at the same time threads will pause and wait till there is room for them. So it's not a 100% guarantee that multithreading is faster when are dealing with an other application.

[topblast]

Omg, are you brains less or did't you read what I typed? You can't mesure time with GetTickCount! Intel will have an other TickCount in 1 seconde then amd. And its imposable that you have in 2 runes the same result..

And what did you test? How to print as fast as posable a messange? Use this in game when you render your menu. The game also needs threads, and if you have more threads then your system can run at the same time threads will pause and wait till there is room for them. So it's not a 100% guarantee that multithreading is faster when are dealing with an other application.

Its just a test, wasn't in the mood to go researching better tickcounts.

yes other threads may pause to run a little thing that is done many times a second, so i can finish it faster, instead of holding up one of the most important threads to do things that could save time(whats the point in the physics thread, if it is in a separate thread if u cannot see the graphics it is doing). These hacks are mostly processor side, not like we are using the GPU to help run these hacks and do the calculations that is needed for the menus. Getting these things done quickly and allowing the CPU to go back to the game in my opinion is good enough for me.

my quad core is running over 1100 threads right now, add / holding 4 doesn't seem like it will do much.

[Deadeys]

Its just a test, wasn't in the mood to go researching better tickcounts.

Then don't say that Intel is better then AMD, and btw you compair 2 CPU setups that don't cost the same.

yes other threads may pause to run a little thing that is done many times a second, so i can finish it faster, instead of holding up one of the most important threads to do things that could save time(whats the point in the physics thread, if it is in a separate thread if u cannot see the graphics it is doing).

it can do well also with those while loops that are in the hacks in this section, parallel_for will help them alot.

Running 4 threads cost more cpu power then 1 thread. It's true that mostly more threads are faster but how more threads you use how more work the CPU needs to do. If you are spanning 100 threads to change 100 addresses then it cost more time then 1 thread changes 100 addresses.

If you span alot of threads it can be buggy. If there is a thread that needs to wait till a thread is finished it will hold 1 thread place. If you span 4 threads when the cpu can handel 4 threads then it will slow down the thread that needs to wait. And if those 4 threads need to wait till the other thread is done.. Then you have a big problem.

So spanning as much threads as posable is a bad idee. You need to know what you are doing. The people here don't know what they are doing so don't let them use more threads then one.

These hacks are mostly processor side, not like we are using the GPU to help run these hacks and do the calculations that is needed for the menus. Getting these things done quickly and allowing the CPU to go back to the game in my opinion is good enough for me.

Can you tell me how it's posable that crossfire doen't need much cpu/gpu power and that a silly menu does? Normaly you don't need multithreading for a simple menu hack :\. I made a while ago a menu hack, I never had a lag problem...

[~FALLEN~]

Deadeys has a point, I wouldn't use GTC for synchronization or for time even. theres multiple ticks per second :/ if you really wanted to figure out how much time has passed you could use timegettime( ... ) or time( ... ) or something of that nature.

As far as asynchronous multi-threading i would go for something like a page lock or critical sections. something of that nature. but you really dont need to multi thread for a hack to be honest, just use prims and keep your code optimized and use the correct compiler settings and u shouldnt lose any fps or performance.

[topblast]

Then don't say that Intel is better then AMD, and btw you compair 2 CPU setups that don't cost the same.





Running 4 threads cost more cpu power then 1 thread. It's true that mostly more threads are faster but how more threads you use how more work the CPU needs to do. If you are spanning 100 threads to change 100 addresses then it cost more time then 1 thread changes 100 addresses.

If you span alot of threads it can be buggy. If there is a thread that needs to wait till a thread is finished it will hold 1 thread place. If you span 4 threads when the cpu can handel 4 threads then it will slow down the thread that needs to wait. And if those 4 threads need to wait till the other thread is done.. Then you have a big problem.

So spanning as much threads as posable is a bad idee. You need to know what you are doing. The people here don't know what they are doing so don't let them use more threads then one.



Can you tell me how it's posable that crossfire doen't need much cpu/gpu power and that a silly menu does? Normaly you don't need multithreading for a simple menu hack :\. I made a while ago a menu hack, I never had a lag problem...

I said intel is better because they use Hyper Threading, u kno 2 threads in a core and amd doesnt. I kno that more threads will be more stressful to the cpu but I want to explore the language and find different ways to do thing and improve performance in every little way i can.

---------- Post added at 11:28 PM ---------- Previous post was at 11:24 PM ----------

Deadeys has a point, I wouldn't use GTC for synchronization or for time even. theres multiple ticks per second :/ if you really wanted to figure out how much time has passed you could use timegettime( ... ) or time( ... ) or something of that nature.

As far as asynchronous multi-threading i would go for something like a page lock or critical sections. something of that nature. but you really dont need to multi thread for a hack to be honest, just use prims and keep your code optimized and use the correct compiler settings and u shouldnt lose any fps or performance.

I already use prims, but my quest to mainly improve the speed of the draw font. if i can draw some of those chars faster i would be happy.

BeginStatic() //Locks the Vertex buffer
AddStaticText (...) // fills the vertex buffer's vertexes
// bla bla bla
AddStaticText (...) // fills the vertex buffer's vertexes
EndStatic() // unlock the vertex buffer
RenderStatic...
ClearStatic // DISCARD the vertexs

[Deadeys]

Try to avoide sleeps, that will help you alot. You can put realtime procces like hotketcheak in a thread. Bla bla.

Btw, delete the sleep in your test and run it again . Your test is not fair with that sleep.

[topblast]

Try to avoide sleeps, that will help you alot. You can put realtime procces like hotketcheak in a thread. Bla bla.

Btw, delete the sleep in your test and run it again . Your test is not fair with that sleep.

if it makes u happy i will find a better tick test.

[Deadeys]

if it makes u happy i will find a better tick test.

I already gave you one. But the reason why the single threaded is a lot slower:

1 Thread:
msg = 1 ms
sleep = 50 ms
msg = 1 ms
sleep = 50 ms
msg = 1 ms
sleep = 50 ms
msg = 1 ms
sleep = 50 ms

2 threads:
msg-msg = 2 ms
sleep-sleep = 50ms
msg-msg = 2 ms
sleep-sleep = 50ms

As you can see, multi thread sleeps at the same time, single thread needs to do all the sleeps after each other. This meens that the sleep is the cause of the difference.

__

Test under heavy load (Phenom II x4):

If you redo the test without sleep (tickcount):

Output 0
Output 1
Output 2
Output 3
Output 4
Output 5
Output 6
Output 7
Output 8
Output 9
Output 10
Output 11
Output 12
Output 13
Output 14
Output 15
Output 16
Output 17
Output 18
Output 19
Output 20
Output 21
Output 22
Output 23
Output 24
Output 25
Output 26
Output 27
Output 28
Output 29
Output 30
Output 31
Output 32
Output 33
Output 34
Output 35
Output 36
Output 37
Output 38
Output 39
Output 40
Output 41
Output 42
Output 43
Output 44
Output 45
Output 46
Output 47
Output 48
Output 49
Time normal : 31

Output 38
Output 13
Output 0
Output 26
Output 39
Output 44
Output 14
Output 1
Output 27
Output 45
Output 40
Output 15
Output 2
Output 28
Output 41
Output 46
Output 16
Output 3
Output 29
Output 42
Output 47
Output 17
Output 30
Output 4
Output 43
Output 48
Output 18
Output 31
Output 5
Output 49
Output 19
Output 32
Output 6
Output 20
Output 33
Output 7
Output 10
Output 21
Output 11
Output 8
Output 34
Output 22
Output 9
Output 35
Output 12
Output 23
Output 37
Output 36
Output 25
Output 24
Time multi : 125

As I said, the sleep was the problem, this is with a good time function:

Output 0
Output 1
Output 2
Output 3
Output 4
Output 5
Output 6
Output 7
Output 8
Output 9
Output 10
Output 11
Output 12
Output 13
Output 14
Output 15
Output 16
Output 17
Output 18
Output 19
Output 20
Output 21
Output 22
Output 23
Output 24
Output 25
Output 26
Output 27
Output 28
Output 29
Output 30
Output 31
Output 32
Output 33
Output 34
Output 35
Output 36
Output 37
Output 38
Output 39
Output 40
Output 41
Output 42
Output 43
Output 44
Output 45
Output 46
Output 47
Output 48
Output 49
Normal: 0.0128041

Output 38
Output 13
Output 0
Output 26
Output 39
Output 44
Output 14
Output 1
Output 27
Output 40
Output 45
Output 15
Output 2
Output 28
Output 46
Output 41
Output 16
Output 3
Output 29
Output 42
Output 47
Output 4
Output 17
Output 30
Output 43
Output 48
Output 18
Output 5
Output 31
Output 49
Output 19
Output 6
Output 32
Output 20
Output 7
Output 10
Output 33
Output 11
Output 8
Output 21
Output 34
Output 22
Output 9
Output 12
Output 35
Output 23
Output 37
Output 36
Output 24
Output 25
Multi: 0.122748

Also useless... 50 runs is not much..

Lets do 5k runs, and use cls to clean the screen so we can see the output.

Normal: 0.401239
Multi: 10.9652

This is better..

Lets do 50k runs:

Normal: 3.16472
Multi: 109.457

50k, make 2 threads max with multi threading:

Normal: 3.2298
Multi: 3.12841

A littel bit better

Now with 4:

Normal: 3.20476
Multi: 3.41695

Hmm, that sucks...

___

Without a heavy game that takes multiple threads:

50k

Normal: 3.8366
Multi: 3.384

5k

Normal: 0.427616
Multi: 0.335064

I guess you know enought now :P.