makepp_sandboxes - Online sa Cloud

PROGRAMA:

NAME

makepp_sandboxes -- Paano maghati ng makepp build

DESCRIPTION

D: --magtayo,
--huwag-magtayo,
--huwag basahin,
--magbasa, I: --sa-sandbox,
--sa loob-sandbox, O: --out-of-sandbox, S: --sandbox,
--sandbox-babala,
--sandbox-babala, V: --virtual-sandbox

Mayroong ilang mga dahilan kung bakit gusto mong hatiin ang file tree para sa isang makepp
magtayo:

1. Kung alam mo na ang karamihan sa puno ay hindi apektado ng anumang pagbabagong ginawa sa
source file mula noong nakaraang build, pagkatapos ay maaari mong sabihin sa makepp na ipagpalagay ang mga file na iyon
sa mga bahaging iyon ng puno ay napapanahon na, na ang ibig sabihin ay hindi man lamang implicitly
nilo-load ang kanilang mga makefile, pabayaan ang pag-compute at pagsuri sa kanilang mga dependency. (Tandaan
na ang tahasang na-load na mga makefile ay nilo-load pa rin, gayunpaman.)

2. Kung marami kang proseso ng makepp na nag-a-access sa parehong puno, gusto mong itaas
isang error kung nakita mo na ang dalawang magkasabay na proseso ay sumusulat sa parehong bahagi ng
tree, o ang isang proseso ay ang pagbabasa ng isang bahagi ng puno na ang isang kasabay na proseso ay
pagsusulat. Sa alinmang paraan, mayroon kang kundisyon ng lahi kung saan ang kaugnay na pagkakasunud-sunod ng mga kaganapan
sa dalawang magkasabay na proseso (na hindi matitiyak) ay maaaring makaapekto sa resulta.

May sandboxing facility ang Makepp na tumutugon sa parehong mga alalahanin.

Sandboxing Options
Maaaring gamitin ang mga sumusunod na opsyon sa makepp para itakda ang mga katangian ng sandboxing ng subtree
ibinigay ng landas at lahat ng mga file nito at mga potensyal na file:

--huwag-magtayo landas
--do-build landas
Itakda o i-reset ang property na "dont-build". Ang anumang file na may set ng property na ito ay ipinapalagay na
maging up-to-date na, at walang mga build check na isasagawa. Ang default ay i-reset
(ibig sabihin, "do-build"), maliban kung mayroon kang "RootMakeppfile", kung saan lahat ng bagay
sa labas ng subtree id nito na "dont-build".

--sandbox landas
--sa-sandbox landas
--sa loob-sandbox landas
--out-of-sandbox landas
Itakda o i-reset ang property na "in-sandbox". Ang isang error ay nakataas kung gagawin ng makepp kung hindi man
magsulat ng file na may ganitong pag-reset ng property. Ginagawa pa rin ang mga pagsusuri sa pagbuo, maliban kung ang
Nakatakda din ang "dont-build" property. Nakatakda ang default (ibig sabihin, "in-sandbox"), maliban kung
may anumang --sandbox mga opsyon, kung saan ang default para sa lahat ng iba pang mga file ay
i-reset (ibig sabihin, "out-of-sandbox").

--sandbox-babala
--sandbox-babala
I-downgrade ang mga paglabag sa "in-sandbox" at "dont-read" sa mga babala sa halip na mga error.
Ito ay kapaki-pakinabang kapag may daan-daang mga paglabag, upang makolekta mo ang lahat
ang mga ito sa isang solong pagtakbo at gumawa ng naaangkop na aksyong pagwawasto. Kung hindi, makikita mo lang
isang paglabag sa bawat makepp invocation, at hindi mo alam kung ilan ang natitira hanggang
lahat sila ay naayos na.

--huwag-basahin landas
--magbasa-basa landas
Itakda o i-reset ang property na "dont-read". Ang isang error ay nakataas kung gagawin ng makepp kung hindi man
magbasa ng file na may ganitong set ng property. Ang default ay i-reset (ibig sabihin, "do-read").

--virtual-sandbox
Huwag muling isulat ang mga build info ng mga file na hindi ginawa ng proseso ng makepp na ito. Ito
ay kapaki-pakinabang kapag nagpapatakbo ng kasabay na mga proseso ng makepp na may magkakapatong na sandbox, at ikaw
ay tiyak na walang dalawang proseso ang magtatangka na bumuo ng parehong target. Makepp will
pagkatapos ay pigilin ang pag-cache ng karagdagang impormasyon tungkol sa mga file na binabasa nito, dahil
baka may iba pang kasabay na magbabasa.

Nalalapat ang bawat isa sa 3 property na ito sa buong subtree, kasama ang mga file na hindi
umiiral pa. Ang mga mas partikular na path ay nag-o-override sa mga hindi gaanong partikular na path. Ang isang tinukoy na landas ay maaaring isang
indibidwal na file, kahit na wala pa ang file.

Kung ang isang property ay parehong nakatakda at ni-reset sa eksaktong parehong landas, ang opsyon na lalabas
inuuna ang pinakamalayo sa kanan sa command line.

Sandboxing para Pagpabibilis
Kung gusto mong pigilan ang makepp na mag-aksaya ng oras sa pagproseso ng mga file na alam mo na
up-to-date (sa partikular, ang mga file na binuo ng isang build tool maliban sa makepp),
pagkatapos --huwag-magtayo ay ang pagpipilian para sa iyo.

Sa ngayon, ang pinakakaraniwang kaso para sa gayong pag-optimize ay alam mo na ang lahat ay hindi
sa o sa ibaba ng panimulang direktoryo ay napapanahon na. Ito ay maaaring ipaalam sa
makepp gamit ang "--huwag-magtayo /. --do-build .".

Sandboxing para Kasabay Mga Proseso
Ang isang diskarteng makakabawas sa build latency ay ang pagkakaroon ng maraming proseso ng makepp na gumagana
sa parehong puno. Ito ay medyo mas mahirap pangasiwaan kaysa sa paggamit ng -j pagpipilian,
ngunit maaari rin itong maging mas epektibo dahil:

· Sa sandboxing, maaaring tumatakbo ang mga proseso sa maraming host, halimbawa, sa pamamagitan ng trabaho
sistema ng pagpila. Ang pagtaas ng -j nauubos ng limitasyon ang mga mapagkukunan ng CPU ng a
nag-iisang host, at maaari pang makapagpabagal sa pagbuo dahil sa labis na proseso ng forking.

· -j Kasalukuyang hindi inihahalintulad ang ilan sa mga gawaing nakakaubos ng oras ng makepp gaya ng paglo-load
makefiles, pag-scan, pagbuo ng mga implicit na dependency habang nag-ii-scan, at nagsusuri
dependencies.

Ang pinakamalaking panganib sa diskarteng ito ay ang build ay maaaring maging nondeterministic kung
mga prosesong maaaring magkasabay na nakikipag-ugnayan sa isa't isa. Ito ay humahantong sa pagbuo ng mga sistema
na gumagawa ng mga hindi tamang resulta nang paminsan-minsan, at walang simpleng mekanismo upang matukoy kung bakit
nangyayari ito

Upang matugunan ang panganib na ito, ipinapayong hatiin ang puno sa mga kasabay na proseso
na kung ang anumang proseso ay nag-access sa filesystem nang hindi wasto, kung gayon ang isang error ay
deterministikong itinaas kaagad. Karaniwan, ito ay nagagawa sa pamamagitan ng pagtatalaga sa bawat isa
sabay-sabay na proseso ng isang "sandbox" kung saan pinapayagan itong magsulat, kung saan ang mga sandbox ng no
maaaring mag-overlap ang dalawang magkasabay na proseso.

Bilang karagdagan, ang bawat proseso ay nagmamarka sa mga sandbox ng anumang iba pang posibleng kasabay na mga proseso
bilang "dont-read." Kung ang isang proseso ay nagbabasa ng isang file na isa pang kasabay na proseso ang may pananagutan
para sa pagsusulat (at samakatuwid ay maaaring hindi pa naisulat), pagkatapos ay isang pagkakamali ang itinaas
kaagad.

Sandboxing para Pagkakasunod-sunod Mga Proseso
Kapag ang build ay nahati para sa kasabay na mga proseso ng makepp, kadalasan ay mayroon ding a
sunud-sunod na ugnayan sa pagitan ng iba't ibang pares ng mga proseso. Halimbawa, maaaring mayroong a
dosenang kasabay na mga proseso ng pag-compile, na sinusundan ng isang proseso ng link na hindi maaaring magsimula
hanggang sa makumpleto ang lahat ng mga proseso ng pag-compile. Ang ganitong mga magkakasunod na relasyon ay dapat na
ipinapatupad ng anumang mekanismo na nag-oorkestra sa iba't ibang proseso ng makepp (halimbawa,
ang sistema ng pagpila ng trabaho).

Kapag ang mga proseso ay may alam na magkakasunod na relasyon, karaniwang hindi na kailangang itaas ang isang
error kapag na-access nila ang parehong bahagi ng puno, dahil ang resulta ay gayunpaman
deterministiko.

Gayunpaman, sa pangkalahatan ay kapaki-pakinabang na tukuyin --huwag-magtayo mga pagpipilian sa umaasa
proseso (ang proseso ng link sa aming halimbawa) na nag-aabiso sa mga lugar na mayroon na
na-update ng mga kinakailangang proseso (ang pag-compile ng mga trabaho sa aming halimbawa). Dito sa
paraan, iniiwasan namin ang karamihan sa mga hindi kinakailangang gawain ng mga null-building na target na makatarungan
na-update.

Gumamit ng makepp_sandboxes online gamit ang mga serbisyo ng onworks.net