Mabagal ang Visual Studio sa isang VPN share: bakit nagiging mga paglalakbay pabalik-balik ang pag-save

Ang isang solusyong bumubukas sa isang segundo mula sa lokal na disk ay tumatagal ng tatlumpung segundo mula sa isang share na naaabot sa pamamagitan ng tunnel. Bihirang ang tunnel mismo ang dahilan. Ang nagbabago ay ang mga operasyong dating lokal na tawag ay nagiging sabayang paglalakbay pabalik-balik, at nagsasagawa ang editor ng ilan sa mga ito bago lumitaw ang window. Ipinapaliwanag ng mekanismong nasa ibaba kung bakit mahal ang bawat isa at alin ang maaari mong alisin.

Ano ang ginagawa ng editor habang bukas ang isang file

Ang editor na may pagsubaybay ng pagbabago ay may subscription sa bawat bukas na file. Ang lokal na volume ay nagseserbisyo ng subscription na iyon mula sa file system nang walang network. Sa pamamagitan ng share, ang parehong tampok ay maaaring lumala sa paulit-ulit na pagbasa ng metadata, dahil ang modelo ng abiso ay hindi kumikilos nang pareho sa SMB. Ang pag-off ng pagsubaybay ng pagbabago ay isang patas na unang eksperimento, dahil inaalis nito ang isang buong klase ng mga kahilingan nang hindi hinahawakan ang tunnel.

Nagdadagdag ang project system ng sarili nitong trapiko. Ang pag-load ng solusyon ay naglilista ng mga direktoryo, nagbabasa ng mga project file at maaaring magsuri ng SDK o mga pakete, at bawat pagsusuri ay isang paglalakbay pabalik-balik kapag malayo ang landas. Ang solusyong may maraming proyekto ay nagpaparami ng bilang na iyon, kaya lumalaki ang oras ng pagbukas nang mas mabilis kaysa sa iminumungkahi ng mga laki ng file.

Mga paghahanap ng shell na nag-expire bago lumitaw ang menu

Nagdadagdag ang Windows ng pangalawang pinagmumulan ng pagkaantala na walang kinalaman sa IDE. Ang Explorer at ang mga shell extension nito ay muling nilulutas ang mga printer, naka-map na drive at shortcut na ginamit noon tuwing bumubukas ang isang context menu. Kapag ang mga target na iyon ay nasa network na hindi naaabot ng tunnel, bawat paglutas ay humaharang hanggang ma-expire ang isang timeout, at saka pa lamang iginuguhit ang menu. Kaya naman ang right-click ay maaaring mag-hang ng ilang segundo habang normal namang bumubukas ang file mismo.

Alisin ang mga patay na mapping at pila ng printer, o itago lamang ang mga umiiral sa network kung saan ka talaga naroon. Sinasaklaw ng parehong pangangatwiran ang lahat ng naglulutas ng landas sa background, kabilang ang mga listahan ng kamakailang file at naka-pin na folder.

net use
Get-Printer | Select-Object Name, PortName
Measure-Command { Get-ChildItem \files\proj | Out-Null }

Bakit nananalo ang lokal na kopya ng trabaho

Ang pagtatrabaho nang direkta sa share ay ang pinakamasamang setup para sa edit-build-test loop, dahil ang editor, compiler at version control client ay bawat isa ay hiwalay na nagbabasa ng mga malayong file na iyon. Bawat isa sa kanila ay nagbabayad ng sariling paglalakbay pabalik-balik, at ang isang build ay nagbabayad isang beses kada file. Ang lokal na kopya na may push sa pamamagitan ng repository ay pumapalit sa isang baha ng maliliit na pagtawid ng isang sadyang pagtawid. Hindi bumuti ang link; bumagsak ang bilang ng mga pagtawid.

Ito ay isang struktural na pagbabago at hindi isang pagsasanay sa pag-tune, at iyon mismo ang dahilan kung bakit gumagana ito kapag hindi gumagana ang mga setting ng tunnel. Ginagawa rin nitong halata ang mode ng pagkabigo: kung mabagal pa rin ang build gamit ang lokal na kopya, hindi kailanman ang share ang problema.

Ilipat ang kasaysayan bilang isang object

Kapag ang repository mismo ay kailangang tumawid sa tunnel, ipadala ang kasaysayan sa isang object sa halip na lakarin ito. Ang bundle ay isang file at kaya isang transfer, samantalang ang isang checkout na lumalakad sa libu-libong maluwag na object ay nagkakahalaga ng libu-libong pagtawid. Sinusuportahan ng Mercurial at Git ang parehong hugis na iyon.

hg bundle --base 9f2c1a7e outgoing.hg
hg unbundle outgoing.hg
git bundle create repo.bundle main
git clone repo.bundle repo

Ang base revision ang bahaging kailangang tamaan, dahil ito ang nagpapasya kung gaano karaming kasaysayan ang maglalakbay. Gumagana ang pag-bundle ng lahat ngunit nag-aaksaya ng link, samantalang ang pag-bundle mula sa huling karaniwang pagbabago ay naglilipat lamang ng kulang sa kabilang panig.

Sukatin ang tatlong operasyon bago sisihin ang bandwidth

Sukatin ang tatlong bagay nang hiwalay: isang maliit na file na binuksan, isang direktoryo na inilista, isang pag-save na natapos. Kung ang tatlo ay mabagal sa proporsyon sa bilang ng file, ang gastos ay mga paglalakbay pabalik-balik. Kung ang isa ay natigil habang maayos ang iba, maghinala ng timeout laban sa isang hindi maabot na resource at hindi bandwidth. Itala kung aling network ang kinalalagyan ng makina sa bawat pagtakbo, dahil ang laptop na muling kumokonekta sa ibang profile ay maaaring magbago ng sagot sa pagitan ng mga pagtatangka.

Pagkatapos ay ulitin ang parehong tatlo laban sa isang lokal na kopya ng proyekto. Ang pagkakaiba ay ang presyo ng share, at iyon ang bilang na dapat banggitin kapag may nagmungkahi ng mas mabilis na link bilang solusyon.