Wave / Variable Access in Thread Groups

Share icon

Hello everybody

I am stuck with some code and need help:
I am running a lot (~2500) of simple fits on a lot of data sets (~3000 with 2500 points each). The fitfunction is always the same and I only need one coefficient. Unfortunately one fit depends on the one before. The data sets are independent. A normal version takes about 6 hours to run (which is 7 sec for one data set). Processor load is about 18% on an i7 8-core system. The bottle neck is identified as the many calls to funcfit.
The typical approach would be to parallelize along the data sets.

Here is my struggle:
-- The fitfunction takes a while to compute (and is normalized anyway, I only need the amplitude coefficient). It is about 2 times faster to compute it before and then just use the data from the computed wave (Still some improvement if I sacrifice it).
-- The fitfunction might be measured data, hence there is no way to compute it.

Is there a way to provide the same wave to a lot of threats without copying it all the time?
I could get around the computed ("$") wave reference by introducing more fitfunctions.


Threadsafe Function DeconvolutionFuncPCOdd(wc,wy,wx):Fitfunc
Wave wc, wy, wx
Wave DCO=$"root:NAC:Experiment:FitDeconvolutionOdd"+SelectString(wc[4],"","Fitted")
	wy=wc[0]+wc[1]*DCO(x-wc[2])
End


The other relevent fragments are (and ThreadGroupPutDF does not work the way I hoped it would work)

		NVar Period=root:NAC:Experiment:ChopperPeriod, Win=root:NAC:Machine:DeconvolutionWindow
		NewDataFolder root:NAC:MT
		Duplicate /O root:NAC:Experiment:FitDeconvolutionOdd root:NAC:MT:FitDeconvolutionOdd
		Duplicate /O root:NAC:Experiment:FitDeconvolutionEven root:NAC:MT:FitDeconvolutionEven
		Duplicate /O root:NAC:Experiment:FitDeconvolutionOddFitted root:NAC:MT:FitDeconvolutionOddFitted
		Duplicate /O root:NAC:Experiment:FitDeconvolutionEvenFitted root:NAC:MT:FitDeconvolutionEvenFitted
		Variable /G root:NAC:MT:Chopper=Period, root:NAC:MT:DeconvolutionWindow=Win
		Variable TID, NThr=1
		TID=ThreadGroupCreate(NThr)
		ThreadGroupPutDF TID, root:NAC:MT
		For (i=0;i<DimSize(DeconPrep,1)-1;i+=NThr)
			For (j=0;j<NThr;j+=1)
				If (i+j < DimSize(DeconPrep,1)-1)
					If (!DeconFlag[i])
						ThreadStart TID, j, DeconvolutePulseMT(DeconPrep, i, Deconvolution, SelectString(Mod(i,2), "Even", "Odd"), Fitted)
						//DeconvolutePulseMT(DeconPrep, i, Deconvolution, SelectString(Mod(i,2), "Even", "Odd"), Fitted)
					EndIf
				EndIf
			EndFor
			Do
			While (ThreadGroupWait(TID, 50)!=0)
			ProgressValue=i
			DoUpdate /W=NAC_Control			
		EndFor
		TID=ThreadGroupRelease(TID)


and (the NVARs can be passed as variables to the function)

ThreadSafe Static Function DeconvolutePulseMT(Data, Index, Result, Parity, Fitted) 
Wave Data
Variable Index
Wave Result
String Parity
Variable Fitted
NVar Win=root:DeconvolutionWindow, Period=root:ChopperPeriod
//Variable Win=0.025, Period=2
Variable YOffset=0
Variable Step, Shift
	Make /FREE /N=4 /O FitCoef 
	Make /FREE /N=(DimSize(Data,0)) Process
	SetScale /P x, DimOffset(Data,0), DimDelta(Data,0), "", Process
	Duplicate /FREE Process Diff, Int, Subtr
	Process=Data[p][Index]
	Step=DimDelta(Data,0)
	Diff=0
	Int=0
	Subtr=0
	SetScale /P x, 0, Step, "", Diff, Int
	For (Shift=0;Shift<Period+9*Win;Shift+=Step)
		FitCoef={0, 1, 0, Fitted}  //  Offset, Amp, Shift
		SetScale /P x, -Shift, Step, "", Process, Subtr
		FuncFit /N /NTHR=1 /Q /W=2 /H="1011" $"DeconvolutionFuncPC"+Parity FitCoef Process(-Win,+Win)
		StrSwitch(Parity)
			Case "Odd":
				DeconvolutionFuncPCOdd(FitCoef,Subtr,Subtr)
				Break
			Case "Even":
				DeconvolutionFuncPCEven(FitCoef,Subtr,Subtr)
				Break
		EndSwitch
		Process-=Subtr[p]
		Diff[X2Pnt(Diff,Shift)]+=FitCoef[1]
	EndFor
	Integrate /P Diff /D=Int
	SetScale /P x, -5*Win, Step, "", Int
	Result[][Index]=Int[p]
	Killwaves Process, Int, Diff, Subtr
	Return NoError
End


Maybe I can pass the fitting wave as an x-wave to the fitfunction, but I don't like these botched constructs.

The goal is to reconstruct the energy input into a detector by measuring a response function and the actual experiment.
The data is too noisy to perform this task with Fourier transformations (and I'm a little bit sad about this).

I know that shared data in a multithread environment is dangerous and usually should be avoided, but since this is read only only access it should be safe.

Long post: potato available on request.

Thanks a lot,
Hans J Drescher
To my knowledge every thread has always its own datafolder hiearachy. So there is no way to share data between them.

But couldn't you move the datasets just around?
So you partition the number of datasets and let each work thread do all the fits on one dataset and then the next dataset, and so on.

So the steps would be something like:
- Partition data sets
- Start worker threads
- Let worker threads initialize themselves. The idea would be that you move all one time initialization, especially the 
Make
parts at the beginning and do that only once before the very first fit.
- Start the inner loop in the worker thread which waits for input data in the queue. As soon as it gets data it will perform all 2500 fits on one dataset.
- Start sending out datafolders with one dataset at a time at the threads. You can move the datafolders with the data if you remember that the worker threads return them.
- Collect the results from the output queues of the worker threads.

January 22, 2015 at 03:18 am - Permalink
Thank you!

I was hoping that I could avoid queues.
I'm implementing it at the moment, when I am done I'll share my results.
HJ

January 22, 2015 at 11:37 am - Permalink