With Multi-Threading memory management

Similar Questions

• Urgent: continous recorders of NIDAQmx and other instruments with multi-threaded vc ++

  I'm working on a software with vc ++ to control several instruments including a NO-DAQmx6289. For example, the features of the software.

  1. communicate with data acquisition card (card data acquisition) and continuously acquire data from several channels at a frequency of 1 kHz.

  2. connect with function via port RS232 1 generator, sending triggered bursts to the real-time features generator change state Ultrasound (G_usstatus) variable.

  3. connect with optical switch via RS232 2 port, send signals to switch between the two input channels (0,1) and six output channels (2,3,4,5,6,7) to the specified user to sequence and time interval (default: 150 ms), real-time change the channel connection variable (G_optchannel).

  4. in real-time, record data and the corresponding ultrasound status and connection status of optical channel in a specified file use for later analysis.

  I use multiple threads to make data acquisition (1-wire), control of the function (2 wire) generator and optical switch (3 wire).  I also need save data acquisition of data and the corresponding ultrasound status and use the connection status of optical channel in a specified file for later analysis. I use the following codes to read data continuously.

  Sub DataCollectionWin::ConnectDAQ()
  {DAQmxErrChk (DAQmxCreateTask ("", & taskHandle));}
  DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle,"Dev1/ai0","",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
  DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle,"Dev1/ai0,Dev1/ai1,Dev1/ai2,Dev1/ai3,Dev1/ai4,Dev1/ai5,Dev1/ai16,Dev1/ai17,Dev1/ai18,Dev1/ai19,Dev1/ai20,Dev1/ai21,Dev1/ai6,Dev1/ai7,Dev1/ai22","",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
  DAQmxErrChk (DAQmxCfgSampClkTiming(taskHandle,"",1000.0,DAQmx_Val_Rising,DAQmx_Val_ContSamps,60000));

  DAQmxErrChk (DAQmxRegisterEveryNSamplesEvent (taskHandle, DAQmx_Val_Acquired_Into_Buffer, 50, 0, EveryNCallback, NULL));
  DAQmxErrChk (DAQmxRegisterDoneEvent(taskHandle,0,DoneCallback,));

  DAQmxErrChk (DAQmxStartTask (taskHandle));

  Error:
  If (DAQmxFailed (error))
  {
  DAQmxGetExtendedErrorInfo (errBuff, 2048);
  MessageBox (errBuff);
  DAQmxStopTask (taskHandle);
  DAQmxClearTask (taskHandle);
  return;
  }

  }

  Int32 CVICALLBACK EveryNCallback(TaskHandle taskHandle, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData)
  {
  char l_optstatus_s [1] l_optstatus_e [1];
  char l_usstatus_s [1] l_usstatus_e [1];

  /*********************************************/
  Reading DAQmx code
  /*********************************************/
  If (! m_bStopTracking)
  {
  l_usstatus_s [0] = g_usstatus [0];
  l_optstatus_s [0] = g_optstatus [0]; Switching State optical before reading the data of 50 * 15

  DAQmxErrChk (DAQmxReadAnalogF64(taskHandle,50,10.0,DAQmx_Val_GroupByScanNumber,data,50*15,&read,));

  SetEvent (hEvent);
  l_usstatus_e [0] = g_usstatus [0];
  l_optstatus_e [0] = g_optstatus [0]; Status of the ///optical at the end of the reading of the data of 50 * 15

  If (read > 0) / / / save data in an exl file specified by "datafile".
  {

  Indicator = 1;

  for (i = 0; i<>
  {(/ / fprintf(datafile,"%d\t",i);}
  fprintf(datafile,"%c\t",l_usstatus_s[0]);
  fprintf(datafile,"%c\t",l_usstatus_e[0]);
  fprintf(datafile,"%c\t",l_optstatus_s[0]);
  fprintf(datafile,"%c\t",l_optstatus_e[0]);
  fprintf(datafile,"%.2f\t",data[15*i]);
  fprintf(datafile,"%.2f\t",data[15*i+1]);
  fprintf(datafile,"%.2f\t",data[15*i+2]);
  fprintf(datafile,"%.2f\t",data[15*i+3]);
  fprintf(datafile,"%.2f\t",data[15*i+4]);
  fprintf(datafile,"%.2f\t",data[15*i+5]);
  fprintf(datafile,"%.2f\t",data[15*i+6]);
  fprintf(datafile,"%.2f\t",data[15*i+7]);
  fprintf(datafile,"%.2f\t",data[15*i+8]);
  fprintf(datafile,"%.2f\t",data[15*i+9]);
  fprintf(datafile,"%.2f\t",data[15*i+10]);
  fprintf(datafile,"%.2f\t",data[15*i+11]);
  fprintf(datafile,"%.2f\t",data[15*i+12]*5);
  fprintf(datafile,"%.2f\t",data[15*i+13]*5);
  fprintf(datafile,"%.2f\n",data[15*i+14]*5);
         
  }
    
  fflush (stdout);
    
  }
  }
  }

  Now the problem is the data acquired with daq card does not match the corresponding registered swtich optical status (G_optchannel, which specifies the light connecting channels). High readings expected certain status really appeared in any other situation.  It seems that there is a misalignment of the multi-thread data. Because the optical switching State passes to 150ms, so I put DAQmxRegisterEveryNSamplesEvent to be trigued each 50samples, which means 50ms with 1 kHz sampling to avoid missing the changes. I also check if there is any change of status during the DAQmxReadAnalogF64, by registering l_optstatus_s and l_optstatus_e, which are actually the same. I wonder if this is because the data are first registered in the buffer. When the software starts reading, at that time, optical swtich status no longer reflects the State when the data was recorded first. Is it possible to fix this?  Thank you very much!

  kGy,

  I'm glad to hear that you are progressing with your project.  Timestamp data are always a bit tricky, because the process of querying a counter on the CPU is done asynchronously with the acquisition of your DAQ hardware.  However, your equipment will ensure that the relative chronology between samples is consistent (in your case, the data will be sampled every 1 ms).  And since you have changed your program as you are now all samples acquired reading, you know that each sample follows the previous 1ms.  So, if I were to implement this I think that I take an initial horodotage when I started the task and to calculate the timestamp for all samples following this timestamp (timestamp SampleN = (*.001s + horodotage initial N) or timestamp SampleN = timestamp SampleN 1 +. 001 s).

  I would go to do that, rather than the timestamp of the end of the reading for the following reason.  As I mentioned previously, the reminder of your reading will run when the OS is planning.  Therefore, it is possible that it gets delayed or does not exactly in phase with the acquisition of hardware, and make adjustments to your code to handle this problem.  However, when you're timestamping there is another thing to pay attention to.  It's the fact that your hardware has a FIFO where sampled data can accumulate before getting transferred to the memory buffer that reading from (for example if the bus PCI were busy when the sample was acquired).  Now assume that the stars aligned against us and get the following:

  (1) the operating system is busy with other things, and our reminder read gets delayed a few ms.

  (2) at the same time, another device connects the PCI bus (or part of the data path between your device and the memory used for the buffer).

  (3) one or more samples is momentarily blocked in FIFO of the device.

  If you were to read data timestamp at the moment, your timestamp would reflect the data in the buffer as well as data that was flying in the FIFO of your device.  However, you can only read data in the buffer.  Thus, time stamp applied to data that you just read would be a millisecond or two later they should be.  Suppose that on the next read reminder, this condition has cleared up itself.  This timestamp taken here would be accurate, however, you will need to return some additional samples (those who were stuck in the FIFO last time).  If you backcalculation your timestamp at this stage, I think that the timestamp calculated for these ecaple timestamps calculated on the previous reading.  It wouldn't be ideal, nor would it reflect when the data has been actually sampled.

  One of the remaining challenges is how exactly the start of time stamp feature.  To do this, I would like to add a call to DAQmxTaskControl (taskHandle, DAQmx_Val_Task_Commit) before calling DAQmxStartTask.  This step will advance the State template DAQmx as far as possible without actually starting the task.  This will help to DAQmxStartTask as soon as possible.  Now, before the appellant beginning or immediately after, I would take my initial horodotage (perhaps timestamp before and after and take the average).  Then I would use this original time stamp and my sampling rate known to calculate timestamps for all the rest of my samples.

  That got a bit long, but I hope it has been helpful.

  Dan

• You can use pfile instead of spfile with automatic shared memory management

  I decided to use the pfile instead of spfile method, because you can make comments in the file pfile. This became very useful however I think that I might be giving up some things.
  
  I want to know if I can use Automatic Shared Memory Management with a pfile.
  
  Also you can make to change the pfile to the database file. Example:
  change the system {some parameter} scope =... I would like here to pfile.
  
  Is this possible. I don't want to have to keep switching back, and I don't want to lose what I put in the pfile file. I read a great article in Oracle magizine on best practices for Oracle and one of them was to not use the spfile. Now, I can't find the article.

  Dear friend
  feature managent automatic memory or dynamic SGA , can not be used when you
  use pfile as meathod initialization of the instance. To use the dynamic SGA feature you
  must use the spfile.
  As you know the current status or the size of the SGA is determined by the
  Parameter SGA_TARGET , and when you want to change the size of the SGA for instnace this setting
  must be updated dynamically without restarting the ORACLE SERVER.

  And as a pfile cannot be updated by the ORACLE SERVER, it must be changed manually.
  so you cannot use automatic memory management while you use startup pfile.

  I hope this helps...

• Problem with multi thread accessing

  He gets exception immediately if more then 2 threads are reading data from a vmdk file.

  Here is the code example:

  http://www.iscsicake.com/iSCSI/VMTest2008.12.21.rar

  You can serialize (including reading/writing) on a disk at a level higher than vixDiskLib?

  Thank you

  Annick

• Satellite C660 shows blue screen (memory management)

  I have a C660-24f, which is around the age of 12 months, and I had the problem with it since I got it.

  There suddenly restart with blue screen (memory management).

  > I have a C660-24f, which is around the age of 12 months, and I had the problem with it since I got it.
  Why wait so long? You may contact Toshiba service whenever you want and ask for help, or at least for the good advice.

  Have you tried to do something about it?
  Clean installation of recovery maybe? Have you noticed this error when the laptop works with the factory settings?

• Resizing a picture of structure within a DLL using the memory manager

  Hi all

  I dug deep inside the rooms, but has failed to find a solution to my problem.

  I am building a dll, which made a few imageprocessing and must return an array of structures to labview, with a struct for each element of the image.

  Because I do not know the number of items in advance and at the limit of the number is a number of magnitude higher than expected, I don't want to allocate such a huge part of memory before the dll call in labview.

  In an older version, I used a table 2d for the elements, where each line contains the values of each element. Here I used the function NumericArrayResize, which worked very well. But I have to add several subprocesses and using structs (or clusters in labview) seems to be more useful and more clean to me, I had also some items back and Foreword climb several times.

  For example, a struct element must take 2 single beds and 1 uint32. My question now is, how can I resize this table of struct with memory manager, functions as the NumericArrayResize functions is not suitable for this purpose?

  (Access to an array of structures inside the DLL and after reading the changed values in Labview is surprisingly easy )

  Thanks in advance

  Well, I was able to solve it myself. I found this thread, where the first rolfk post made me think. It seems to me that the numericarrayresize function behaves very similar to the function realloc of c. so I used the unsigned int type 8 (which is just a byte) and multiplied by the number of bytes used by a struct, in my case 12 bytes (4 + 4 + 4) and multiplied it by the number of structures (elements of the image) I. Fortunately, it worked and the block of memory has been resized, exactly as I wanted it to be. Important note: do not forget to adjust the size of the handle element, otherwise Labview does not know the size has changed.

• need help:(windows 8 plusieurs bsod se bloque c'est à dire.) memory management, irql not..., kernel mode...

  https://drive.Google.com/file/d/0B0ATyEKasqZmbkpPNG1WSXd0STA/edit?USP=sharing

  theres a link to all my minidumps.

  I don't know what to do, I have many BSODs in a row and then many times where I can use the computer for hours. It seems completely random. That this has something to do with the closures of power?

  Thank you!

  BUGCODE_USB_DRIVER (FE)

  This indicates that an error occurred in a bus universal series (USB) driver.

  3: kd > k
  Call child-SP RetAddr site
  fffff880'014f81e8 fffff880'0464 484 nt c! KeBugCheckEx
  fffff880 '014f81f0 fffff880' 04615ce2 USBPORT! USBPORT_ProcessURB + 0 x 36644
  fffff880 '014f8310 fffff880' 04615afd USBPORT! USBPORT_PdoInternalDeviceControlIrp + 0 x 52
  fffff880 '014f8360 fffff880' 047536f1 USBPORT! USBPORT_Dispatch + 0x17d
  fffff880 '014f83c0 fffff880' 047533ca usbhub! 0x1f1 + UsbhPdoInternalDeviceControl
  fffff880 '014f8430 fffff880' 0104f0a7 usbhub! UsbhGenDispatch + 0x9a
  fffff880 '014f8460 fffff880' 058f63b6 Wdf01000! imp_WdfRequestSend + 0x4b3
  fffff880'014f84f0 fffffa80'05468700 netr28ux + 0x9a3b6
  fffff880 '014f84f8 fffffa80' 0559db30 0xfffffa80'05468700
  fffff880 '014f8500 fffffa80' 055a 1020 0xfffffa80'0559db30
  fffff880 ' 014f8508 00000000 00000000 of ' 0xfffffa80 ' 055a 1020

  netr28ux.sys is the series of Ralink RT2870 USB802.11n driver wireless card (you can have another manufacturer).

  PAGE_FAULT_IN_NONPAGED_AREA (50)

  This indicates that invalid system memory was referenced.

  Bug control 0 x 50 usually occurs after the installation of a faulty hardware or installation failure of material (usually associated with defective RAM, either main memory, L2 RAM or RAM video cache).

  Another common cause is a defective system service installation.

  Antivirus software can also trigger this error, as can a corrupted NTFS volume.

  Bugcheck 50, {fffff12014494a90, 1, fffff803968f06f5, 2}

  Address fffff12014494a90 wrote in the statement to the address fffff803968f06f5.

  3: kd > r cr2
  Last set context:
  CR2 = fffff12014494a90

  The address of 1 parameter was stored in cr2 before calling the page fault handler.

  3: kd >! fffff12014494a90 pte
  GO fffff12014494a90
  PXE to the EPP of FFFFF6FB7DBEDF10 at FFFFF6FB7DBE2400 at FFFFF6FB7C480510 at FFFFF6F8900A24A0 PTE POE
  contains 0000000000000000
  not valid

  3: kd > dd fffff12014494a90
  fffff120'14494 has 90? ???????? ???????? ????????
  fffff120'14494aa0? ???????? ???????? ????????
  fffff120'14494ab0? ???????? ???????? ????????
  fffff120'14494ac0? ???????? ???????? ????????
  fffff120'14494ad0? ???????? ???????? ????????
  fffff120'14494ae0? ???????? ???????? ????????
  fffff120'14494af0? ???????? ???????? ????????
  fffff120'14494 b 00? ???????? ???????? ????????

  Of the above, we can see that the address fffff12014494a90 is indeed invalid. That being said, why fffff12014494a90 try to write in fffff803968f06f5?

  3: kd > kv
  Child-SP RetAddr: Args to child: call Site
  fffff880 '09db76f8 fffff803' a 969385, 0: 00000000'00000050 fffff120 '14494a 90 00000000 00000001' fffff880' 09db78e0: nt! KeBugCheckEx
  "fffff880 '09db7700 fffff803' 968b1acb: 00000000 ' 00000001 fffff120" 14494a 90 fffffa80 '07a14b00 fffff803' 968c0db0: nt! : FNODOBFM: 'string' + 0x33e2a
  "" fffff880 '09db77a0 fffff803' 96874eee: 00000000 ' 00000001 fa80041a ' b89004c2 fffff680 ' 36587700 fffff880 ' 09db78e0: nt! MmAccessFault + 0x55b
  fffff880 '09db78e0 fffff803' 968f06f5: fffff803 ' 9684f363 fffffa80 '041ab868 06cafaf0' 06cafaf0 fffffa80 ' 07a 05010: nt! KiPageFault + 0x16e (TrapFrame @ fffff880'09db78e0)
  fffff880 '09db7a78 fffff803' 9684f363: fffffa80 ' 041ab868 06cafaf0 '06cafaf0 fffffa80' 07a 05010 fa80041a ' b89004c2: nt! MiResolveDemandZeroFault + 0x5
  "fffff880 '09db7a80 fffff803' 968b1e1c: 00000000 ' fffffa80 00000000 '07a14b00 fffff880' 09db7b80 fffffa80 ' 0615b 568: nt! MiProtoFault + 0x1a3
  fffff880 '09db7b00 fffff803' 96874eee: 00000000'00000000 00000000' 550280cb 0000006c 'af0ef501 fffff880' 09db7c40: nt! MmAccessFault + 0x8ac
  fffff880 '09db7c40 000007fd' c1ee0a00: 00000000'00000000 00000000'00000000 00000000'00000000 00000000'00000000: nt! KiPageFault + 0x16e (TrapFrame @ fffff880'09db7c40)
  0000006c 'af0ef530 00000000' 00000000: 00000000'00000000 00000000'00000000 00000000'00000000 00000000'00000000: 0x000007fd'c1ee0a00

  3: kd > .trap fffff880'09db78e0
  NOTE: The frame trap does contain not all registers.
  Some registry values can be set to zero or incorrect.
  Rax = 0000000000000002 rbx = 0000000000000000 rcx = 0000000000000000
  RDX = fffff8a00a6dd000 rsi = 0000000000000000 rdi = 0000000000000000
  RIP = fffff803968f06f5 rsp = fffff88009db7a78 rbp = fffffa8007a14b00
  R8 = 0000000000000000 r10 = fffff8a00a6dd000 fffff6fc500536e8 = r9
  R11 = 0000000006cafaf0 r12 = 0000000000000000 r13 = 0000000000000000
  R14 = 0000000000000000 r15 = 0000000000000000
  iopl = 0 nv up ei pl zr po nc
  nt! MiResolveDemandZeroFault + 0 x 5:
  fffff803'968f06f5 4 c 89442418 mov qword ptr [rsp + 18 h], r8 ss:fffff880'09db7a90= fffffa8007a05010

  Address to education, we failed on, fffff803'968f06f5 deferenced RER + 18 h where rsp + 18 h is fffff88009db7a78. This would result in a write from memory at the address fffff880'09db7a90.

  3: kd >! PTE fffff880'09db7a90
  GO fffff88009db7a90
  PXE to the EPP of FFFFF6FB7DBEDF88 at FFFFF6FB7DBF1000 at FFFFF6FB7E200270 at FFFFF6FC4004EDB8 PTE POE
  contains 0000000000624863 contains 0000000000623863 contains 0000000038208863 contains 800000004123C 963
  GetUlongFromAddress: cannot read fffff80396b750e4
  NFP 624 - DA - KWEV NFP 623 - DA - KWEV NFP 38208 - DA - KWEV NPF 4123c - G-DA - KWEV

  3: kd > dd fffff880'09db7a90
  fffff880'09db7a90 fffffa80 b89004c2 fa80041a a 07, 05010
  fffff880' 96b6e700 00000000 00000011 fffff803 09db7aa0
  fffff880'09db7ab0 a927a274 ffff2ad2 c0000016 00000000
  fffff880'09db7ac0 fffff880 afaf0000 0000006c 09db7c40
  fffff880'09db7ad0 fffff880 afaf0000 0000006c 09db7c40
  fffff880'09db7ae0 00000000 00000000 fffff8a0 0a6dd000
  fffff880'09db7af0 00000000 968b1e1c fffff803 c0000016
  fffff880'09db7b00 00000000 00000000 fffffa80 07a14b00

  Right, so code wanted to write to fffff880'09db7a90 which, as we can see above is a valid address. The 1st parameter and cr2 however note that we have not written to the address fffff12014494a90.

  nt! MiResolveDemandZeroFault said the material to write in fffff880'09db7a90 (who once again of incidentally is a completely valid address), and the material came back and said 'I can't write fffff12014494a90.

  However, this seems very material right here - nom_processus: avgrsa.exe is an associated AVG process at the time of the accident.

  MEMORY_MANAGEMENT (1A)

  This indicates that an error occurred serious memory management.

  Error checking 1 a, {5003, fffff70001080000, 620, 62200000 c 50}

  -1 setting of the bug check is 5003 which lists free work is corrupt. It is usually a hardware error, however, a device driver causing corruption is possible as well at times.

  ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY (CF)

  This indicates that an attempt was made to execute non-executable memory.

  KMODE_EXCEPTION_NOT_HANDLED (1e)

  This indicates that a kernel-mode program generated an exception which did not catch the error handler.

  3: kd > k
  Call child-SP RetAddr site
  fffff880 '02af70b8 fffff801' da400c56 nt! KeBugCheckEx
  fffff880 '02af70c0 fffff801' da34c4bd nt! KiFatalExceptionHandler + 0 x 22
  fffff880 '02af7100 fffff801' da3743d4 nt! RtlpExecuteHandlerForException + 0xd
  fffff880 '02af7130 fffff801' da34e216 nt! RtlDispatchException + 0 x 458
  fffff880 '02af7840 fffff801' da2df842 nt! KiDispatchException + 0 x 455
  fffff880 '02af7f00 fffff801' da2dd59f nt! KiExceptionDispatch + 0xc2
  fffff880 '02af80e0 fffff801' da461287 nt! KiInvalidOpcodeFault + 0x11f
  fffff880 '02af8270 fffff801' da31cfe4 nt! : FNODOBFM: 'chain' + 0 x 16175
  fffff880 '02af8360 fffff880' 052d50f4 nt! KeSetEvent + 0x1c3
  fffff880 '02af83d0 00000000 fffffa80' netr7364 + 0x320f4
  fffff880'02af83d8 fffffa80 '0xfffffa80 00000000' 00000000
  fffff880 '02af83e0 fffffa80' 06de3152 0xfffffa80'00000000
  "fffff880'02af83e8 fffffa80 ' 07039808 0xfffffa80 ' 06de3152
  fffff880 '02af83f0 fffffa80' 06de3018 0xfffffa80'07039808
  fffff880 '02af83f8 ' 00000003 00000004 0xfffffa80' 06de3018
  "fffff880 '02af8400 00000000' 00000026 0 x 00000003 00000004"
  fffff880 '02af8408 fffffa80' 06e08580 0 x 26
  fffff880 '02af8410 fffffa80' 0688a 038 0xfffffa80'06e08580
  fffff880 '02af8418 fffffa80' 06dade40 0xfffffa80'0688 has 038
  fffff880 '02af8420 fffffa80' 06df6d10 0xfffffa80'06dade40
  fffff880 '02af8428 fffff880' 052aae7a 0xfffffa80'06df6d10
  fffff880 '02af8430 fffffa80' 06e00000 netr7364 + 0x7e7a
  fffff880 '02af8438 fffffa80' 0688 to 000 0xfffffa80'06e00000
  "fffff880'02af8440 fffffa80 ' 00000066 0xfffffa80 ' a 0688, 000
  fffff880 '02af8448 fffffa80' 0000013a 0xfffffa80'00000066
  fffff880 '02af8450 fffffa80' 06de3018 0xfffffa80'0000013 has
  fffff880 '02af8458 00000000' 0000000 0xfffffa80 a' 06de3018
  fffff880 '02af8460 fffffa80' 0688a 000 0xa
  fffff880 '02af8468 fffff880' 03ce647c 0xfffffa80'0688 has 000
  fffff880 '02af8470 00000002' 00000122 usbehci! EHCI_SubmitTransfer + 0 x 88
  fffff880 '02af84b0 0000057f' f8f2a800 0x00000002 "00000122
  fffff880 '02af84b8 fffff880' 010386be 0x0000057f'f8f2a800
  fffff880'02af84c0 fffff880'053088 Wdf01000 5 c! imp_WdfRequestReuse + 0x19a
  fffff880 '02af8530 fffffa80' 070d57f0 netr7364 + 0x658c5
  fffff880 '02af8538 ffff0000' 079b03f3 0xfffffa80'070d57f0
  fffff880 ' 02af8540 00000000 00000000 of ' 0xffff0000 ' 079b03f3

  netr7364.sys again.

  FAILURE_BUCKET_ID: 0x1E_c000001d_BAD_IP_netr7364 + 320f4

  It looks like a bad instruction pointer.

  -------------------------

  1. remove and replace AVG with built-in Windows Defender from Windows 8 for temporary troubleshooting purposes because it can cause conflicts NETBIOS:

  -AVG removal http://www.Avg.com/us-en/utilities

  Windows Defender (how put on after the withdrawal)- http://www.eightforums.com/tutorials/21962-Windows-Defender-turn-off-Windows-8-a.html

  2 if the above fails, please run Memtest for no. LESS than ~ 8 going on (several hours):

  Memtest86 +:

  Download Memtest86 + here:

  http://www.memtest.org/

  Which should I download?

  You can either download the ISO pre-built you want to burn to a CD and then boot from the CD, or you can download the automatic installer of the USB. What this will do is format your USB drive, make a boot device and then install the necessary files. Both do the same job, it's just you that you choose, or you have available (be it CD or USB).

  Note that some older generation motherboards do not support USB boot, your only option is CD (or floppy if you really wanted to).

  How Memtest works:

  Memtest86 writes a series of test patterns for most of the addresses of memory, reads the written data and compares it to find errors.

  The default pass is 9 different tests, varying in the modes of access and test data. A tenth test, bland, is selectable in the menu. He wrote all the memory with zeros, then sleeps 90 minutes before checking to see if the bits have changed (perhaps because of refresh problems). This is repeated with all those for a total time of 3 hours by pass.

  Many chipsets can report RAM speed and timings by SPD (Serial Presence Detect) or EPP (Enhanced Performance Profiles), and some even support changing the expected memory speed. If the expected memory speed is overclockee, Memtest86 can test that memory is free of error with these faster settings.

  Some hardware is able to report the status of the "PAT" (PAT: active or PAT: disabled). This is a reference to the Intel performance acceleration technology; There may be the BIOS settings that affect this aspect of memory synchronization.

  This information, if it is available for the program, can be displayed via a menu option.

  Other questions, they can most likely be answered by reading this excellent guide here:

  http://Forum.canardpc.com/threads/28864-FAQ-please-read-before-posting

  Kind regards

  Patrick

• Multi-threading

  I am looking to buy a new Mac Pro.  There are options that are inspired mainly by what applications you clocked.  He suggests that apps that don't take advantage of the multi-threading will perform better on processors with clock speeds higher while those who will benefit more from hearts.  Lightroom will perform better with more cores or a higher clock speed?

  Lightroom takes advantage of multiple threads so that saturates the CPU sometimes, but a lot of time, there are some other bottleneck on the system like i/o to disk or video memory so that thread or cpu optimization gains are dumb.

• Multi threading issue.

  Hello
  I have worked on a project and would be grateful if I have a solution for this. The issue I'm facing is when two admin update the details of a "user" at the same time there are lines that are unique in the table. Here I use the framework KODO to remove and insert new values into the table when the administrator clicks the button Save. (here being complex update, delete, and insert is used).
  
  so when two admin clicks of the button simultaneously duplicate lines occur in the table.
  
  How can I solve this problem, I think using Sync is a bad option as he eats performance.
  Is there a way to correct this multi threading issue in java without locking or wielding resources (such as application performance does not diminish), since this part of my commonly used web application?

  The normal way to avoid this problem is to have a unique index on the table that prevents duplicate entries.

  I wouldn't delete the entry, only insert the entry if it does not exist and update it if it isn't.

  If you block on a unique key for the user/line (rather than the entire table) your overhead costs will be about 2 microseconds. It is very small for an interaction with the user-driven application. You could lock the whole table which may limit your request to about 100 updates per second, but would be much simpler to manage. Personally, if administrators perform more than 100 updates per second there is something wrong with your model.

  In short I just lock the entire table and optimize if it proves to be a problem.

• Multi threading in flex concept?

  Hello

  I have an application with 4 quandrants. Each name separate webservice and based on the data in result I get, I build user interface elements dynamically. Unfortunately, I have to wait for each manager result in order to complete the construction of the user interface. Is it possible to run all 4 result together managers?

  Ex:

  I have 4 webservices: ws1, ws2, ws3 and ws4. I pass some parameters and invoke these services, complete creation:

  WS1. OperationName.Send ();

  WS2. OperationName.Send ();

  WS3. OperationName.Send ();

  WS4. OperationName.Send ();

  ws1ResultHandler(event:ResultEvent):void

  {

  }

  ws2ResultHandler(event:ResultEvent):void

  {

  }

  ws3ResultHandler(event:ResultEvent):void

  {

  }

  ws4ResultHandler(event:ResultEvent):void

  {

  }

  From the Web service operation which is managed to get the first data, this particular manager fires. Once all of the code in this handler is executed, she then gets in the next operation of webservice result handler.

  Is there a way to trigger all these handlers together and build together dynamically user interface elements at once?

  Appreciate your ideas on this.

  "Is there a way to trigger all these handlers together and build the UI together dynamically at THE SAME time?"

  Excuse my small edit, but the answer is 'no '. Flex is not multi-threaded.

  You can look at why it takes so long to build the user interface as a problem.

• Satellite A200 - 1 GB WXP - unknown PCI memory manager

  After getting my A200 - 1 GB I also installed windows xp and now I use my laptop with xp and vista. After downloading all the drivers for windows xp on the Toshiba site, I installed it and now the problem: all the material r ok, but I have an unknown device-> PCI memory manager in Device Manager.

  Anyone? I need help...

  Someone here in the forum suggested that the controller memory PCI is Intel Turbo Memory, also called Intel Flash cache logic chip also called device Robson.
  It's quite new technology designed to support the new features of Vista.
  There is not driver for it for Windows XP because XP doesn t supports the function of cache, it is supported by Vista.

• TS200 hangs with the new memory

  Hello

  I have a new TS200 (A 6522, 11) which came with a 1 GB UDIMM (and the system boots fine with that).

  I just tried to replace that memory with a 4 GB RDIMMS with the following specifications:

  Kingston KVR1333D3D4R9S / 4G

  4 GB PC3 - 10600 CL9 REG parity

  When I start the system with just this memory installed, I get the following:

  Initialization of the IMM
  IMM initialized memory
  Loading the kernel IMM
  Operation of the IMM kernel
  (delay)
  BNC has begun
  (delay)
  Network initialized
  Remote Power Control available
  Thermal management online
  Flash Manager ready
  Online video remote engine
  Ready IPMI sensor scan
  Available VPD
  SALT initialized
  Ready for the initialization of the uEFI
  uEFI boot
  (delay)
  Initialization of system - do not turn the system off
  (cleared screen)
  uEFI boot

  Then a few seconds later Amber '! ' symbol on the front panel lights up the server.

  Thoughts or comments appreciated.

  Ian was soon

  
  

• Memory Manager virtual incorrect declaration of free space

  In Windows 2008 R2, I am trying to move the paging file on drive E: which is 4,09 4,09 free TB TB.
  When in virtual memory Manager, I click on drive E: it see the Space Available: 97602 MB.
  I have 128 GB of ram in the server, and it's not enough space for the size of swap file I need, not to mention the fact that it is a bad report.
  I tried inputing the initial and maximum custom size I need, but it said E: is to small for the maximum paging file.

  Everywhere wherever I look in Windows 2008 R2 it reports the correct size for E: except in The Virtual Memeory Manager.

  Anyone has an idea how to solve or work around this problem?
  I really need to move the file pageing on the C: drive.

  Hello

  The question you posted would be better suited in the TechNet Forums. I would recommend posting your query in the TechNet Forums:

  http://social.technet.Microsoft.com/forums/en-us/winserverhyperv/threads

• get a small box with "out of memory on line 17.

  I get a small box with "out of memory on line 17" inside, how remedy

  Hi dawn,

  Please see the thread similar to this for an answer:

  http://answers.Microsoft.com/en-us/Windows/Forum/Windows_7-windows_install/message-from-webpage-out-of-memory-on-line17/a102a1f1-f857-E011-8dfc-68b599b31bf5

• LabVIEW built of DLL in an application multi-threaded C++, need help!

  I'm working on a software application which is developed mainly in C++. There is a component of this larger application, however, develop in LabVIEW (for several reasons that I dive in here). This LabVIEW code is therefore run in a C++ wrapper class that calls a built DLLS LabVIEW.

  All this was fine and dandy, until we decided to multi-threaded, our C++ application for an increase in performance. Accordingly, the LabVIEW DLL now is called from multiple threads simultaneously. While this works on a functional level, it seems to create a bottleneck.  All my tests, it is resource locking occurs, such that only one thread has access to the .dll at a time. If I do the .vi used to define the dll as a non-reentrant function prototype so it's what we see. For example, say we have 3 sons all calling the same .dll method call. Thread 1, 2, 3 and all call the .dll file in a few milliseconds of each other. Thread 1 has completed the call .dll after X milliseconds. Thread 2 has finished the .dll call after 2 X milliseconds, and wire 3 full after 3 x milliseconds.

  Now, changing the vi home and runs the same test, we see wire 1, 2, 3 and all end them the call of .dll in 3 x milliseconds. While the fact that they are now the same amount of time to complete you would lead to believe they are spend at the same time, the fact that it takes 3 x milliseconds as opposed to X milliseconds means that they are not.

  Has anyone ever dealt with these issues before? Is it possible to play with the "delivery system" for the vi will have an effect? What happens if .dll methods while remaining attached to the same .dll are called from different threads? Same behavior? Is it a lost cause? Is there any way to make the code in a DLL only built LabVIEW run in two different threads at the same? What I understand is easily achievable with a normal (non - built LV) .dll.

  Please, if anyone has any advice in this area, let me know!

  Much appreciated,
  Jesse Hurdus

  Hi jhurdus,

  I know that you are working with an engineer OR this question, but I wanted to post a reply to one of your last questions.

  When you use the function node library call in LabVIEW, there is the possibility to select 'Run in the user interface thread' or 'run in any thread '.  This option, according to the help file for LabVIEW (dialog box call library functions), allows the developer to pass thread library function node call from the (default) user interface thread to the thread that the VI is running.  Additional details of when you want to switch the thread of execution are in the help file.

  Kevin S.

  Technical sales engineer

  National Instruments