▁Norm ally , ▁when ▁a ▁variable ▁is ▁read / write ▁conflic ting , ▁the ▁solution ▁will ▁be ▁declaring ▁it ▁as ▁shared ▁and ▁protect ing ▁access ▁to ▁it ▁by ▁the ▁critical ▁section , ▁and ▁providing ▁synchron ization ▁when ▁needed . ▁Due ▁to ▁the ▁fact ▁that ▁adding ▁more ▁elements ▁into ▁the ▁critical ▁section ▁decre ases ▁the ▁overall ▁system ▁performance , ▁this ▁technique ▁is ▁avoided ▁as ▁much ▁as ▁possible . ▁ ▁Thus , ▁the ▁variable ▁is ▁checked ▁if ▁it ▁can ▁be ▁reduced ▁first . ▁If ▁it ▁can ' t ▁be ▁reduced , ▁the ▁variable ▁is ▁checked ▁for ▁Priv at ization , ▁taken ▁into ▁consideration ▁whether ▁it ' s ▁more ▁toler able ▁to ▁add ▁the ▁extra ▁private ▁copies ▁or ▁serialize ▁access ▁to ▁the ▁variable ▁through ▁the ▁critical ▁section . ▁ ▁When ▁compared ▁with ▁Red u ction , ▁priv at ization ▁requires ▁one ▁task ▁instead ▁of ▁two ▁separate ▁tasks ▁in ▁the ▁case ▁of ▁priv at ization . ▁This ▁task , ▁in ▁an ▁abstract ▁form , ▁is ▁basically ▁analyz ing ▁the ▁code ▁to ▁identify ▁the ▁priv at izable ▁variables . ▁On ▁the ▁other ▁hand , ▁the ▁two ▁tasks ▁required ▁by ▁Red u ction ▁are : ▁ident ifying ▁the ▁reduction ▁variable , ▁and ▁then ▁parallel izing ▁the ▁reduction ▁operator . ▁By ▁obser ving ▁each ▁of ▁the ▁two ▁techniques , ▁it ' s ▁easy ▁tell ▁what ▁type ▁of ▁overhead ▁each ▁one ▁adds ▁to ▁the ▁parallel ▁program ; ▁reduction ▁increases ▁the ▁computation ▁overhead ▁while ▁priv at ization ▁increases ▁the ▁memory ▁consum ed ▁by ▁the ▁program . ▁ ▁When ▁compared ▁to ▁Exp ansion