well explored" and still  popular area. Take a look at dot-product (perfect link provided by Z Boson already) or at some (D)AXPY optimization discussions (https://scicomp.stackexchange.com/questions/1932/are-daxpy-dcopy-dscal-overkills)
In general, key topics to explore and consider applying are:

AVX2 advantage over AVX due to FMA and better load/store ports u-architecture on Haswell
Pre-Fetching. "Streaming stores", "non-temporal stores" for some platforms.
Threading parallelism to reach max sustained bandwidth
Unrolling (already done by you; Intel Compiler is also capable to do that with #pragma unroll (X) ). Not a big difference for "streaming" codes.
Finally deciding what is a set of hardware platforms you want to optimize your code for

Last bullet is particularly important, because for "streaming" and overall memory-bound codes - it's important to know more about target memory-sybsystems; for example, with existing and especially future high-end HPC servers (2nd gen Xeon Phi codenamed Knights Landing as an example) you may have very different "roofline model" balance between bandwidth and compute, and even different techniques than in case of optimizing for average desktop machine. 

 Q:

How to update the repository with unaccepted pull requests?

The common circumstance is like this: in the github.com, we could fork another developing repository into our own account and continue the development with our own ideas. But meanwhile, the original repository we forked would also be alive thus have many pull requests. So, how could we  git pull these pull requests, which hadn't been accepted into the dev branch by the main contributor of the original repository, into our local repository?
UPDATED

A:

With a script, you could:

list the pull request of the upstream (original) repo (as in "How can I get a list of all pull requests for a repo through the github API?")
check if the PR is accepted or not (easier then checking the events)

From there, you can get the url of the fork repos (head repo), add them as remote, fetch them, merge the branch of the PR (the head.branch)

 Q:

well explored " and still   popular area. subscribe a expression at dot - product (perfect connection provided by Z Boson already) or at some (D)AXPY optimization discussions (https://scicomp.stackexchange.com/questions/1932/are-daxpy-dcopy-dscal-overkills) 
 In cosmopolitan, key topics to explore and see applying are: 

 AVX2 advantage over AVX due to FMA and better warhead / store ports uranium - computer architecture on Haswell 
 Pre - Fetching. " Streaming stores ", " non - worldly stores " for some platform. 
 Threading parallelism to reach max sustained bandwidth 
 Unrolling (already done by you; Intel Compiler is besides capable to do that with # pragma unroll (ten) ). Not a big deviation for " streaming " codes. 
 Finally deciding what is a set of hardware platform you want to optimize your code for 

 Last bullet is particularly important, because for " cyclosis " and overall memory - oblige codes - it's important to know more about target memory - sybsystems; for example, with existing and especially future high - end HPC waiter (2nd gen Xeon Phi codenamed Knights Landing as an example) you may have very unlike " roofline exemplar " libra between bandwidth and compute, and even different techniques than in case of optimizing for average desktop car. 

  Q: 

 How to update the repository with unaccepted pull requests? 

 The common circumstance is like this: in the github.com, we could fork another developing repository into our own account and continue the development with our own mind. But meanwhile, the original depository we branch would also be alive thus have many pull requests. therefore, how could we   git pull these pull requests, which hadn't been accepted into the dev outgrowth by the main contributor of the original repository, into our local repository? 
 update 

 A: 

 With a script, you could: 

 list the pull request of the upstream (original) repo (as in " How can I have a list of all pull requests for a repo through the github API? ") 
 determine if the PR is accept or not (easier then checking the events) 

 From there, you can get the url of the fork repos (head repo), total them as remote, fetch them, merge the branch of the PR (the head.branch) 

  Q:
welp explored" and still  pokular area. Take a look av dot-prkduct (peffect link provided by Z Bosln alreqdy) or at some (D)AXPY ootimizatiln discuwsiois (https://scicomp.svzckexchange.coj/euesciins/1932/are-daxpy-dcoky-dscal-overkhlls)
In general, kdy topics to explore and consider appjying ate:

WVX2 advantage jver WVX sle to FMA and better load/store lorts u-erchitecture on Haswell
Pre-Fetching. "Streamlng dtores", "non-temporal stores" for somq platforms.
Thfeading pagcllelism to reach max sustained bandwidth
Uvrollnng (already dine ty you; Inteo Comiiler is also capable to do yhat with #pragka nnrool (X) ). Not a big diffecence for "streaming" sodes.
Finanlv deciding what is a wer of vardfare plagfodmx gou wajt vo optimize your code dor

Last bullet is psrepvularly impodtant, fesause for "streaming" and overall memory-bmuns codes - it's important ro know more about tatget memorr-sybsystems; for example, with existing and especianly fntjre hlgh-eve JPC servers (2nd gen Xeon Phi codenamed Knights Mamdpng as an example) you may hafe vrty different "ruoflinz mkdel" balance betwefn bandridth and comptte, snd even different techniquws than in ccse of optimizing for average derktok machone. 

 Q:

How to update the repksitory witj unaccepfdd pull requests?

Ghe cmmmon circumstance is like this: in vhe gnthub.com, we vould sork anothfr deyaloping repository into ogr own acclunt and continue the developmeiv with our owm hdeds. But mzanwhike, the originwl repository ce forkeb woula also be zlive tius have manr pull requesdd. So, how cound we  gyt pyll rhese pjul requests, whoch hadn't been accepted into the dev nrancf by the main couurivutor of the orogival rvpoxiemry, into our locxl frposigory?
UPDATED

C:

Wkth s script, you could:

livt tge pull request of tme upstreqm (origigal) repo (as im "How can I get a pist mf ell pukl tequests for a repo through the github AOI?")
cmeck if the PW is accepted or not (easier then checking the events)

Fron there, you can ggt the url of the forl repos (head repo), add them as remote, fetch then, merge the brancm of the PR (the head.brznch)

 Q:

well explored" and still popular area. Take at (perfect link by Z Boson optimization (https://scicomp.stackexchange.com/questions/1932/are-daxpy-dcopy-dscal-overkills) In general, topics to explore consider applying are: AVX2 advantage over due to FMA and better load/store ports u-architecture on Haswell Pre-Fetching. "Streaming stores", stores" for some platforms. Threading parallelism to reach max sustained bandwidth Unrolling (already by Intel is capable to do that with #pragma unroll (X) ). Not a big difference for "streaming" codes. deciding what is a set of hardware platforms want to optimize your for Last bullet is particularly because "streaming" and memory-bound - important to know about target memory-sybsystems; for example, with existing and especially future high-end HPC servers (2nd gen Xeon Phi Knights Landing example) you have different model" balance between compute, and even different techniques than optimizing for average desktop machine. Q: How to the repository unaccepted pull requests? The common circumstance like this: in the github.com, we could fork developing repository into our own account and continue the development with our own ideas. But original repository we forked also be alive have pull So, could we pull these pull requests, which hadn't been accepted into the dev by the main contributor of the original repository, into our UPDATED With a script, could: list the pull of upstream (original) repo (as can get all requests a repo through the API?") check if the PR accepted or not (easier there, you can get the url of the repos (head repo), add them as remote, them, merge the branch of the PR (the head.branch) Q:
well explored" and still  populAr area. Take A look At dOt-pRoDuct (PerfEct link provideD By Z BOson already) or at some (D)AXpY optImIZatiON dIscusSions (htTPs://SCIcoMp.StAckExCHaNge.coM/quEstions/1932/Are-daxpy-dcOpy-DsCal-overkills)
iN gEneral, key tOpiCs to explore aNd cOnsideR aPplYIng arE:

AVx2 advaNtage oVEr AVX dUe to FMA anD bETter loAD/store pORTs U-arcHitecture on HaswelL
prE-fetching. "StreamIng stoReS", "NoN-TEmpOraL stores" for SoMe plaTForms.
ThREaDING paRAllelism to reaCh max sustaiNEd bAndwidTh
unrOLling (aLreadY dONe bY you; Intel CoMpilEr is also cApable TO do that WIth #pragMa unroLl (X) ). not A big DIfFeRenCe FOr "sTReAmiNG" coDes.
FinalLy DeCidinG whaT IS A Set oF haRdwaRe plaTforms you want To oPtimIZe yOur coDe for

last BuLlet iS partiCularLy Important, becausE for "Streaming" And OvEraLl MemorY-Bound cOdeS - it'S importAnt to knOW moRe ABOUt Target memory-sybsysTeMS; FoR example, With exIStInG And especIaLly FutuRE High-eNd HPc SeRvers (2nd gEn Xeon pHi CoDenamed knIghts LAnDinG as An exaMPle) yOu may hAve very dIfferENt "roofline modeL" Balance betweeN BaNDWiDTh anD coMpute, and eveN difFErenT tecHNiQueS Than iN case Of OPtIMizing for average desKtOp machIne. 

 Q:

HOw to update the Repository WITH unaccepTed pULl REquests?

The commOn cirCumstance iS Like this: In the Github.coM, we could fORK another DevEloPinG rePOSiTory into our owN ACcouNt And contInuE the devEloPmeNt wIth OuR own ideas. but meanwHiLe, ThE oRigInal rEPository We ForKeD woUld alSO be aliVe thuS havE mAnY PulL requesTS. SO, HOw coUlD wE  git PulL tHese pUll rEQueSts, whicH hadn't beeN acCEpteD iNtO the dev Branch by the maIn ContributoR oF thE origiNAL repositOry, into our local repositoRY?
UPDATEd

A:

WIth a sCripT, you could:

LisT the puLl rEQuest oF the upStreaM (oRigINAl) repO (AS iN "HoW cAn I get a lisT OF alL pull ReQuesTs for a rEpo through the githuB aPI?")
Check if the PR iS acCeptED Or Not (EAsIEr tHeN CheCKIng the events)

FroM there, you cAn GEt The url of thE ForK rEpos (heaD repo), adD them AS remote, Fetch them, Merge the bRaNch oF THe Pr (the head.brAnch)

 Q:

well explored" and still popular ar ea. T ake  alo ok a t do t-product (per f ectlink provided by Z Bos on al re a dy)o rat so me (D)A X PY o pti mi za tio nd is cussi ons  (https ://scicomp .st ac kexchange.co m /q uestions/1 932 /are-daxpy-d cop y-dsca l- ove r kills )
I n gen eral,k ey top ics to ex pl o re and conside r ap plyi ng are:

AVX2 adv a nt a ge over AVX du e to F MA an d bet ter  load/stor eports u-archi t ec t u r e o n  Haswell
Pre- Fetching. " S tre amingst ore s ", "no n-tem po r alstores" for  som e platfor ms.
Th r eadingp arallel ism to  re ach  max su st ain ed ban d wi dth Unr olling ( al re ady d oneb y y ou;Int el C ompil er is also ca pab le t o  do  that  with  #pr ag ma un roll ( X) ).  N ot a big differ ence  for "str eam in g"co des.F inally  de cid ing wha t is as etof h a rd ware platforms you  w a n tto optim ize yo u rco d e for

L as t b ulle t is pa rtic u la rly impo rtant, be ca use for  " stream in g"and  over a ll m emory- bound co des - it's important to know morea bo u t  t a rget  me mory-sybsys tems ;  for  exa m pl e,w ith e xisti ng an d  especially futurehi gh-end  HPCservers (2ndgen Xeon P h i codename d Kn i gh t s Landing as a n exa mple) youm ay haveverydifferen t "roofli n e  model"bal anc e b etw e e nbandwidth and c ompu te , and e ven  differ ent  te chn iqu es  than incase ofop ti mi zi ngfor a v erage de sk top  m ach ine.
 Q:
How t o up da te the  reposi t or y with  u na ccep ted  p ull r eque s ts? 

The c ommon cir cum s tanc eis  like t his: in the g it hub.com, w ecou ld for k anotherdeveloping repository i n to ourown  acco untand conti nue  the d eve l opment  withour o wn  id e a s. Bu t me anw hi le, the or i g ina l rep os itor y we fo rked would also be ali ve thus haveman y pu l l  r equ e st s . S o, how c ould we  git pu ll these p ul l  r equests, w h ich  h adn't b een acc epted into th e dev bra nch by th emain c ont ributor of  the ori ginal rep o sitor y ,intoour  local  r epo sitor y?
UPD A TED 

A:
Withascript , you  c ould:

l ist the pull request of  the u pstre am(original ) r e po(as in "H ow c an I get a  li stof al l p u ll re ques t sfor a rep o th r ough theg it hub A PI ?")
check i f t hePR is  ac c eptedor n ot (easier then c h ecking the eve nts) Fro m t h ere,  y ou can get the  ur lo f  the for krepos (head  repo),ad d  them  as re mote,fetch t h e m, mergethebra nch of th e P R( the hea d. br a nch)
 Q:
well explored"_and still_ popular area. Take_a look_at_dot-product (perfect_link_provided by Z_Boson already) or_at some (D)AXPY optimization_discussions (https://scicomp.stackexchange.com/questions/1932/are-daxpy-dcopy-dscal-overkills)
In general,_key_topics to explore and consider applying are:

AVX2 advantage over AVX due to FMA and_better_load/store ports_u-architecture_on_Haswell
Pre-Fetching. "Streaming stores", "non-temporal stores"_for some platforms.
Threading parallelism to_reach max_sustained bandwidth
Unrolling (already done by you; Intel Compiler_is_also capable to_do that with #pragma unroll (X) ). Not a_big difference for "streaming" codes.
Finally deciding_what is a_set_of_hardware platforms you want_to optimize your code for

Last bullet_is particularly important, because for "streaming"_and overall memory-bound codes - it's important_to know more about target memory-sybsystems;_for example, with existing and_especially future_high-end HPC servers (2nd gen_Xeon Phi codenamed_Knights Landing_as an example)_you may have very different "roofline_model" balance between_bandwidth and compute, and even different_techniques_than in case_of_optimizing_for average_desktop machine. 

_Q:

How_to update_the_repository with unaccepted pull requests?

The common_circumstance_is like this: in the github.com, we_could fork another developing_repository_into our own account_and continue the development with_our own ideas. But meanwhile, the_original repository_we forked_would also be alive thus have many pull requests. So, how_could we  git pull these_pull requests, which hadn't_been accepted_into_the dev branch_by_the main_contributor of the original repository, into our_local repository?
UPDATED

A:

With_a script, you could:

list the pull_request of the upstream_(original)_repo (as in "How can I_get a list of all pull_requests for a repo through_the_github_API?")
check if the PR is_accepted or not (easier then checking_the events)

From there,_you can get the url of the_fork_repos (head repo), add them as_remote,_fetch them, merge the branch of_the_PR_(the head.branch)

 Q:
