cpu

DWORD WINAPI MyThreadFunction(LPVOID lpParam) { volatile auto x = 1; for (auto i = 0; i < 800000000 / MAX_THREADS; ++i) { x += i / 3; } return 0; } This function is run in MAX_THREADS threads. I have run the tests on Intel Core 2 Duo , Windows 7 , MS Visual Studio 2012 using Concurrency Visualizer with MAX_THREADS=4 and MAX_THREADS=50 . test1 (4 threads) completed in 7.1 seconds , but test2 (50 threads) completed in 5.8 seconds while test1 has more context switches than test2 . I have run the same tests on Intel Core i5 , Mac OS 10.7.5 and got the same results. I decided to benchmark this

I once had the task of determining the following performance parameters from inside a running application: Total virtual memory available Virtual memory currently used Virtual memory currently used by my process Total RAM available RAM currently used RAM currently used by my process % CPU currently used % CPU currently used by my process The code had to run on Windows and Linux. Even though this seems to be a standard task, finding the necessary information in the manuals (WIN32 API, GNU docs) as well as on the Internet took me several days, because there's so much incomplete/incorrect

I am wanting to get a list of all the process names, CPU, Mem Usage and Peak Mem Usage. I was hoping I could use ctypes. but I am happy to hear any other options. Thanks for your time. Bakuriu You can use psutil . For example, to obtain the list of process names: process_names = [proc.name() for proc in psutil.process_iter()] For info about the CPU use psutil.cpu_percent or psutil.cpu_times . For info about memory usage use psutil.virtual_memory . Note that psutil works with Linux, OS X, Windows, Solaris and FreeBSD and with python 2.4 through 3.3. I like using wmic on Windows. You can run it

EDIT: My confusion arises because surely by predicting which branch is taken, you are effectively doing the target prediction too?? This question is intrinsically linked to my first question on the topic: branch prediction vs branch target prediction Looking at the accepted answer: Unconditional branch, fixed target Infinite loop goto statement break or continue statement End of the 'then' clause of an if/else statement (to jump past the else clause) Non-virtual function call Unconditional branch, variable target Returning from a function Virtual function call Function pointer call switch

I heard a lot that data should be properly aligned in memory for better access efficiency. CPU access memory on a word boundary. So in the following scenario, the CPU has to make 2 memory accesses to get a single word. Supposing: 1 word = 4 bytes ("|" stands for word boundary. "o" stands for byte boundary) |----o----o----o----|----o----o----o----| (The word boundary in CPU's eye) ----o----o----o---- (What I want to read from memory) Why should this happen? What's the root cause of the CPU can only read at the word boundary? If the CPU can only access at the 4-byte word boundary, the address

I hear this statement quite often, that multiplication on modern hardware is so optimized that it actually is at the same speed as addition. Is that true? I never can get any authoritative confirmation. My own research only adds questions. The speed tests usually show data that confuses me. Here is an example: #include <stdio.h> #include <sys/time.h> unsigned int time1000() { timeval val; gettimeofday(&val, 0); val.tv_sec &= 0xffff; return val.tv_sec * 1000 + val.tv_usec / 1000; } int main() { unsigned int sum = 1, T = time1000(); for (int i = 1; i < 100000000; i++) { sum += i + (i+1); sum++;