memory-access

I'm trying to compile some code that uses the fmemopen function in MinGW. I found out that this function is not available MinGW. I need a function equivalent to fmemopen() . Are there any alternative functions that I can use? there are no fmemopen equivalents on win32 because of missing functionality in the kernel, I think cygwin implements it using a temp file like this one: https://github.com/kespindler/python-tesseract/blob/master/util-fmemopen.c 来源： https://stackoverflow.com/questions/7307955/is-there-fmemopen-in-mingw

I have a Microsoft visual studio application that is grabbing frames from cameras and I am trying to display those frames in a Qt application. I am doing some processing with the frames using OpenCV, so the frames are Mat objects. I use QThreads to parallelize the application. I am getting a Access Violation reading location when I try to emit a Mat signal from my CameraThread class. main.cpp int main(int argc, char *argv[]) { QApplication app(argc, argv); MainWindow window; window.show(); return app.exec(); } mainwindow.cpp #include "main_window.h" MainWindow::MainWindow() { // create a

Every modern high-performance CPU of the x86/x86_64 architecture has some hierarchy of data caches: L1, L2, and sometimes L3 (and L4 in very rare cases), and data loaded from/to main RAM is cached in some of them. Sometimes the programmer may want some data to not be cached in some or all cache levels (for example, when wanting to memset 16 GB of RAM and keep some data still in the cache): there are some non-temporal (NT) instructions for this like MOVNTDQA ( https://stackoverflow.com/a/37092 http://lwn.net/Articles/255364/ ) But is there a programmatic way (for some AMD or Intel CPU families

It's my understanding that if two threads are reading from the same piece of memory, and no thread is writing to that memory, then the operation is safe. However, I'm not sure what happens if one thread is reading and the other is writing. What would happen? Is the result undefined? Or would the read just be stale? If a stale read is not a concern is it ok to have unsynchronized read-write to a variable? Or is it possible the data would be corrupted, and neither the read nor the write would be correct and one should always synchronize in this case? I want to say that I've learned it is the

Memory access through pointers is said to be more efficient than memory access through an array. I am learning C and the above is stated in K&R. Specifically they say Any operation that can be achieved by array subscripting can also be done with pointers. The pointer version will in general be faster I dis-assembled the following code using visual C++.(Mine is a 686 processor. I have disabled all optimizations.) int a[10], *p = a, temp; void foo() { temp = a[0]; temp = *p; } To my surprise I see that memory access through a pointer takes 3 instructions to the two taken by memory access through

I read that a 64-bit machine actually uses only 48 bits of address (specifically, I'm using Intel core i7). I would expect that the extra 16 bits (bits 48-63) are irrelevant for the address, and would be ignored. But when I try to access such an address I got a signal EXC_BAD_ACCESS . My code is: int *p1 = &val; int *p2 = (int *)((long)p1 | 1ll<<48);//set bit 48, which should be irrelevant int v = *p2; //Here I receive a signal EXC_BAD_ACCESS. Why this is so? Is there a way to use these 16 bits? This could be used to build more cache-friendly linked list. Instead of using 8 bytes for next ptr,