Intel Software Network - <![CDATA[ Pipeline buffer between stages? ]]> feed http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488 en-us Re: Pipeline buffer between stages? "sometimes the first and last pixel does not match"
I would suggest holding a magnifying glass over your own code first. ]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Wed, 28 Oct 2009 23:40:28 -0700 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages?
Quoting - Neeley
I have set up a pipeline that reads image data from a file -> performs a filter -> performs a filter -> output result to the screen. Just to be sure that i had things set up correctly (and I understood what I am doing) I replace the first and last pixel with a frame counter just after reading the data from file in my input stage. Each stage takes precautions to maintain the original frame counter in these pixels. After checking these pixels at my output stage, I am finding that these counters will get out of sinc, sometimes the frame numbers do not stay sequential and sometimes the first and last pixel does not match. I have even set each filter to serial_in_order and still get these odd results. This leads me to believe I should place buffers between my stages. So here are my questions:

1) Should I place a buffer between each stage of the pipeline?
2) How large should these buffers be?
3) Should I use concurrent_queue to implement these buffers?
4) If I push and pop from within  each stages operator() what would I return as a token?
5) Is there a better solution to this problem?

I know that debugging a problem with out seeing the actual code is hard,but any advice on this subject would be greatly appreciated.
Hi,

what about using data-dependent breakpoints in a debugger to find out which thread and from which function write-accesses the first and the last pixel in the image? Since you're saying that you changed all of the stages to be serial_in_order, but the error did not go away, I'd assume that the problem is not with parallelism, but with the image processing code.
]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Thu, 05 Nov 2009 05:30:26 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages?
Hi,

what about using data-dependent breakpoints in a debugger to find out which thread and from which function write-accesses the first and the last pixel in the image? Since you're saying that you changed all of the stages to be serial_in_order, but the error did not go away, I'd assume that the problem is not with parallelism, but with the image processing code.

I have fixed some of the problems that I was having. This is what I am doing now. I the input stage of the code I replace the first and last pixel with the frame number. Then in each of the piplelines that follow the first operation is to copy from the token that is passed into a local array. Then I store the first and last pixel into a local varible. When I leave the stage I replace the first and last pixel with the sotred values and copy into the token that I am passing out. This helped alot but still did not completely fix the problem. I then switched all the stages but the first and last to parallel, now the two stages after the input act as expected, but the last still has problems. I also started printing out the test pixels to individual txt files. one for each stage instead printing to the screen.
]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Thu, 05 Nov 2009 15:05:34 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages? http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Thu, 05 Nov 2009 20:56:41 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages? >> Why copy to a "local array" (seems expensive and useless)?

Raf, how would you do this?

I originally was not doing this, but then I realized that since we are passing a (void*) between filters, if you do not protect the data while filter 2 is reading its input (filter1's output), filter 1 is changing the data. I am now thinking that I should probably wrap the memcpy in a CRITICAL_SECTION to further assure that I am not reading and writing at the same time.

>> What happens if you initialise task_scheduler_init with argument 1? If this does not make the problem go away, what if you actually make the program serial? Are you using vector instructions or plain C++? Note that parallel filters are run right after any preceding filter on the same thread, so if there is a difference with running them serially that should provide a clue.

I started with a serial implementation of this code, so yes things work right when I run it serially. The only reason I started inserting the frame count into the first and last pixel was to convince myself that I did not have concurrencey problems with the threaded implementation. ]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Fri, 06 Nov 2009 08:10:52 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages? Why not allocate a memory buffer for each token (a portion of data processed by filters at once), pass this biffer through all pipeline stages, and free in the last one after the buffer is no more necessary? This way you should have no conflicts between filters. Sorry if I miss the reasons for the buffer being shared. ]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Fri, 06 Nov 2009 09:22:00 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages?
Why not allocate a memory buffer for each token (a portion of data processed by filters at once), pass this biffer through all pipeline stages, and free in the last one after the buffer is no more necessary? This way you should have no conflicts between filters. Sorry if I miss the reasons for the buffer being shared.

Thanks for the input. I think this answers my original question the best so far. I am starting to understand that the pipeline does help with the threading, but memory concurrency is still up to the user. I should have realized this as soon as I saw that the pipe line passes pointers. I think I have found that yes I do need some kind of buffer in between each stage of the pipeline, but those buffers only have to be large enough to ensure that no data races (concurrency issues) occur.   ]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Fri, 06 Nov 2009 12:02:33 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages? #5 "I originally was not doing this, but then I realized that since we are passing a (void*) between filters, if you do not protect the data while filter 2 is reading its input (filter1's output), filter 1 is changing the data."
No, only one filter at a time is using that particular void*, and the referenced data is implicitly synchronised from one filter to the next if only plain C++ is being used. Don't handicap your program's performance with needless protection against imaginary races. The idea is actually that filters are visiting the data, not the other way around, which is important for cache locality. If you need to transform an image, then a void* value can point to two adjacent buffers, with each filter transforming the data directly from one buffer to the other (without an intermediate buffer!), although it would be better still to reuse one buffer if the transformation only needs local data (something like colour shift instead of image warp). ]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Fri, 06 Nov 2009 18:26:42 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages? >>No, only one filter at a time is using that particular void*, and the referenced data is implicitly synchronised from one filter to the next if only plain C++ is being used. Don't handicap your program's performance with needless protection against imaginary races.

This is exactly what I was hoping, but the test did not seem to show this. I must be doing something wrong.

>>The idea is actually that filters are visiting the data, not the other way around, which is important for cache locality.

I will have to get my head around this. Are these buffers created outside the filters or are they members of the filters?

>>If you need to transform an image, then a void* value can point to two adjacent buffers,

Do you mean to use a memory block that is twice as large of the image where the first half is the input and the second half is the output? If not I really do not understand how one pointer can point to two buffers?

>> although it would be better still to reuse one buffer if the transformation only needs local data (something like colour shift instead of image warp).

I have examples of both, will also need to go trough an image and compile a list and in the next filter work on that list.

Are there other exaples for pipeline? I have been locking for some but cannot find any thing but simple string manipulations.  

I thank every one that has commented on this topic. I have tried to figure this out on my own (I even bought and read Reinders book) and only posted the questions here as a last resort. All of your comments are a big help.
]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Fri, 06 Nov 2009 22:05:43 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General Re: Pipeline buffer between stages? "I will have to get my head around this. Are these buffers created outside the filters or are they members of the filters?"
Dealing with buffers is your job, the pipeline only passes void* values from one filter to the next. The values can change from input to output, but the pipeline will try to apply successive filters on the same thread to improve locality. I don't know how important that is here, though, but for understanding what you are seeing you should probably know that successive parallel filters are executed one after the other on the same thread.

"Do you mean to use a memory block that is twice as large of the image where the first half is the input and the second half is the output? If not I really do not understand how one pointer can point to two buffers?"
Yes, just to avoid an intermediate copy. Or you keep them separate, and let each filter read from the input and write to the newly allocated output, which is then passed to the next filter after the input is discarded. Just avoid using an intermediate local buffer with a wasted copying action.

Sorry I couldn't help with the actual problem, which remains a mystery. ]]> http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ Sat, 07 Nov 2009 01:10:58 -0800 http://software.intel.com/en-us/forums/intel-threading-building-blocks/topic/69488/ ISN General