Fórumok
Udv!
Adott egy Thinkpad T430 core i7 CPU-val, 16GB RAM-mal, Debian linux-szal. terminal alol a gradlew nehany perc utan stabilan szetfagy. Annyira, hogy csak power button-nal lehet a gepet kikapcsolni. Install alatt 1GB swap particio keszult, meg azon is gondolkoztam, hogy kell-e egyaltalan. Illetve megfigyeltem, hogy java alkalmazas futtatasa kozben 300+% CPU usage van. Ettol fuggetlenul a CPU nem sul meg, szoval nem tudom, hogy mi lehet az ok. Ha a swap keves, akkor van lehetoseg on the fly novelni reinstall helyett?
koszi elore is
Hozzászólások
Mit látsz a top-on? Felfalja a RAM-ot? Ha van helyed, természetesen tudsz csinálni swap-et, azért nem kell újra telepíteni az oprendszert.
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Igen, sajnos ugy tunik, hogy nagyon felfalja a RAM-ot. Ma reggel kivetelesen lefutott a build, de utana sem "urult" a memoria, es kicsivel kesobb Android Studio alatt meg is tortent a fagyas. Futnom kellene egy kort a SWAP-pel, bar jo lenne, ha a meglevo particiot lehetne atmeretezni, utananezek, hogy vadafak.
Csinaltam egy screenshot-ot a top kimeneterol rogton a build inditasa utan, ott csak az latszik, hogy a java 3-4-500+ %-on megy, de ettol fuggetlenul hajlamos vagyok azt gondolni, hogy a RAM lesz a gond, mivel a CPU max 80 fokig ment fel a build alatt, es a vegeztelvel visszavett mind a tempobol, mind a hobol.
A kepet nem tudom, hogy lehet ide beilleszteni, de ezek utan nem is botos, hogy relevans.
U-dash
És mit csinál a sima gradle?
Nem ertek hozzá, de lehet hogy a jvm alatt fogy el a heap, és emiatt gc-zik állandóan?
Meddig jut el a build?
Nem probaltam, de mivel project szinten a gradlew-t kell hasznalni, lehet, hogy ez itt nem megoldas
U-dash
Ilyet gradle nem tud. HW hiba.
Két opció van:
a, elfogy a szabad memória,
b, hardverhiba, ami terhelés alatt jön ki.
--
Adj hozzá plusz swap és kiderül, melyik.
https://iotguru.cloud
a verzio lett a gyoztes. de megdobbent, hogy 16GB RAM nem eleg a javanak. Kapott 32GB swap-et, igy mar nincs fagyas gond, az "extrem" terheles utan a CPU szepen visszavesz, ahogy kell, a memoriaban viszont eleg sok java prcess "beragad". killall java megoldotta, de oszinten szolva nem tetszik a dolog. Ez van, hw hibat jelenleg kizarnam.
U-dash
Hát, azért 16 GB (17 GB) Android fejlesztésre nem elég... :)
https://iotguru.cloud
Azert en megdobbentem. Durva. Probaltam rakeresni egyeb nyelvek eroforras igenyere, de nem lettem sokkal okosabb.
U-dash
Mindennek jó a sok memória és 16 GB cross-platform GUI fejlesztéshez kevés manapság, az oprendszer és a futó mindenfélék 4-8 GB körül esznek, a maradék meg kevés lesz.
Azok ún. daemon processzek, ha kilövöd azokat, akkor a következő build több idő lesz, mert el kell indítani újra, hagyd, hogy felhasználja a géped a memóriát, azért van, gyorsabb lesz minden... kifizetted a 16 GB minden részét, nem?
https://iotguru.cloud
Hát, nem tudom. Microchip Mplab-X IDE induláskor csinál egy rakás dolgot, parse-olja a forráskódot, hogy tudjon syntax highlight-ot csinálni, miegymás. Az is megdöglik néha, s ha bezárom, akkor is bennmarad java process, amelyet meg kell ölni kill-el. Ha nem fagy meg ez a csodálatos fejlesztői környezet, akkor a bezárását követően nem marad benn java process. Egész egyszerűen képes valahol végtelen ciklusban maradni. Az meg mindennek a teteje, hogy ha meg akarok vele nyitni egy 1 MB-nál nagyobb header file-t, közli, hogy túl nagy, könnyen lehet, hogy bele fog pusztulni, ugye, nem akarom megnyitni. Ekkor marad a Midnight Commander mcview eszköze, vagy bármi más. Nevetségesek ezek a java alkalmazások.
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
És Android alkalmazást fejlesztesz, illetve a gradle a build eszköz?
https://iotguru.cloud
Nem. Egy nagyon hasonló esetet meséltem el egy szintén java-s fejlesztői környezet gyenge pillanatairól. Ez a Microchip Mplab-X IDE, írtam is.
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Igen, valóban mindenkinek lehet gyenge pillanata, neked is.
https://iotguru.cloud
Lényegében belém álltál, mert nem volt jobb dolgod. OK. :-/
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Nem, Gradle build folyamatról volt szó, annak a daemon processzeiről és te bedobtál egy anekdotát valami teljesen más környezetről, de én kérek elnézést.
https://iotguru.cloud
Ez így van. Tiltja valamilyen jogszabály?
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Semmilyen jogszabály nem tiltja, ahogy azt se, hogy ez miatt hülyének gondoljalak. Case dismissed.
https://iotguru.cloud
> Nevetségesek ezek a java alkalmazások.
Az tény, hogy sok ilyen Java alkalmazás van, de hiba ezt a Java rovására írni. Olyan mintha a Windows miatt azt mondanánk, hogy nevetségesek a C-ben írt operációs rendszerek.
Akkor csak java-s alkalmazásokat nem tudnak írni az arra hivatottak.
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Miért, C-s alkalmazást tudnak írni az arra hivatottak?
https://iotguru.cloud
Szerintem az többeknek sikerül, de valóban nincs róla statisztikám, mielőtt azt kérnél. Java-s vackoktól előítéletesen rettegek, szemben a natív C-ben írt alkalmazásokkal.
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Szóval van egy ismerethiányból adódó újabb előítéleted és ebből építed fel a légváradat?
https://iotguru.cloud
Igen. Az előítélet jó dolog. Nem más, mint tapasztalat. Sok esetben kollektív tapasztalat.
tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE
Nem, az előítélet és a tapasztalat nem ugyanaz, az előítélet nem tapasztalatra alapozott, hanem elfogultságból ered és nagyrészt tévutakra visz, megakadályozza, hogy tapasztalatot vagy tudást szerezz a témában.
https://iotguru.cloud
Minden nyelven lehet szar programot írni. Persze az igazi programozó csakis FORTRANban teszi!
okay, koszi.
U-dash
Csak tipp, de azok nem a gradle daemonok voltak?
Csak hogy tisztázzuk: a hiba nem az volt, hogy a memória volt kevés, hanem hogy a SWAP. 16 GB memória mellé legalább 4-8 GB SWAP kell minimálisan, az 1 GB semmire sem elég. És igen, 16 GB memória mellé is kell bőven SWAP-et számolni, mert ez a mennyiség 5-6 évvel ezelőtt számított soknak, ma már nem számít annak.
"Sajnos" a Linux memóriakezelése úgy működik, hogy ha nincs elég memória, akkor kilapátolja a dolgokat a swapre. De ez nem kilobájtos szegmensek alapján működik, komplett egységeket pakol ki, amik teljesen random méretűek is lehetnek, 10 kB-tól 2GB-ig. Ha nincs hova kilapátolni, és még mindig kell a memória, akkor borzasztóan belassul a gép. Nem "fagy le", csak mittudomén 5-10 perceket kell várni dolgokra, de megtörténnek. Nyilván manapság erre senkinek sincs ideje, így "lefagyott!!!" és RESET gomb.
Blog | @hron84
via @snq-
Ez faszság.
Nem, nem így működik, tökéletesen működik swap nélkül is, ameddig van elég a memória. Ha van swap, akkor oda kirakja a ritkán használt dolgokat, hogy több lehessen a buff/cache mérete, de a swap nem kötelező és a hiánya nem hiba.
Ezt a mondatot kijavítottam:
https://iotguru.cloud
Próbáld meg teljesen törölni a .gradle mappát a user home-ból. Néha beragad ott ez-az, produkál ilyet néha.
Ha nem jött be próbálj másik JDK-t. Valami hasonló volt egyszer nekem, akkor az openJDK-ról valamelyik oracle-re váltottam, az segített egy Thinkpad E431-esen, ubuntuval.
koszi, lehet, hogy ezekkel is futok majd egy kort, most orulok, hogy bar fercelve, de muxik.
U-dash
nalam a gradle build 1.5G-t eszik. igaz a grade.propertiesben van egy ilyen sor:
A vegtelen ciklus is vegeter egyszer, csak kelloen eros hardver kell hozza!
org.gradle.jvmargs=-Xmx12g -Xms6g -XX:MaxPermSize=12g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
Nalam igy nez ki. Meggondolando, hogy esetleg ezzel is lehet jatszani...
U-dash
Ha adsz neki 12 GB memóriát, akkor 12 GB memóriát fog használni, ha elég nagy a projekt. Ezek után nem csoda, ha 16+1 GB kevés, úgy, hogy ott fut oprendszer, böngésző, Android Studio, meg toronyóra lánccal.
Lejjebb tudod venni, nyilván ennek az egyik hatása a lassabb build, mert mindig futni fog a GC és kisebb vagy nulla lesz a gradle cache. Másrészt van az a projektméret, aminek ennyi memória kell. Mivel ez projekt szintű beállítás, vélhetően szükség van rá vagy valakinek olyan gépe volt, aminél ez bőven elfért.
https://iotguru.cloud
Az egy elég régi és makacs tévedés hogy a több heap gyorsabb futást eredményez, pláne ilyen extrém méretekben.
Szerintem kb. sorozatgyilkos akinek 4GB-nál nagyobb heap kell egy fordításhoz.
Gábriel Ákos
Az a helyzet, hogy a gradle daemon futva marad, benne eltárolva nagyon-nagyon-nagyon sok dolog, ami a build során keletkezett. Ha nem tudja eltárolni, mert nem fér el, akkor újra elő kell állítania, ami több idő, mintha ott lenne a memóriában.
Vagy Android fejlesztő... :D
Ez esetben ugyanis alapból ~2-3 GB közötti a gradle daemon memória igénye egy kicsi projektnél is, ha van több target, ha pedig a projekt sok egymásra épülő UI tesztet (is) tartalmaz, aminél a forked VM az öngyilkosság, akkor még több memória kell, ha pedig nincs hely a build cache-re, amit eldob a gradle, akkor az ismételt build vagy ismételt tesztfuttatás lassú lesz. Szóval nem ritka a 8-12 GB közötti heap méret egy nagyobb projekt esetén, mert ekkor már mindent el tud tárolni, ami a build során előáll. Érdemes próbálgatni, hogy hol van az a pont, amikor a heap növelése még csökkenti a build időt.
https://iotguru.cloud
Senki nem jött még rá hogy ennyi szemetet tán érdemes lenne diszkre menteni?
Ez akkor implicite azt is jelenti hogy minden reggel ennyi mocskot újra össze kell lapátolni?
Nem bánom hogy nem kell ezzel dolgoznom...
Gábriel Ákos
Minek? Miért fárasszák ezzel az SSD-t vagy a sokkal-sokkal lassabb HDD-t, amikor a memória sokkal gyorsabb és gyakorlatilag nem fárad el x írástól. Ha megvettem 16, 32 vagy 64 GB memóriát, akkor miért ne használjam ki minden egyes bitjét, hogy hatékonyabban dolgozzak?
Igen.
Ettől nem lesz könnyebb az Android fejlesztők élete és a gradle ilyen működése tény marad.
https://iotguru.cloud
Belenéztem a doksijába, lehet a cache-t konfigurálni szépen csak foglalkozni kell kicsit vele.
Gábriel Ákos
Hogyne lehetne. De ettől még mindig az a helyzet, hogy addig érdemes növelni a gradle heap méretét, amíg van belőle csökkenés a build időben. És ez sokszor több, mint 4 GB. Az ember meg eldönti, hogy mi olcsóbb: az ideje vagy a memória.
https://iotguru.cloud
világos. nekem valamiért az eddigi kommunikációból az jött le hogy "jaj nincs mit tenni, venni kell sok ramot még". dehogynincs, csak kicsit utána kell menni.
Gábriel Ákos
Hogyne lenne, lehet adni 1 GB heap a gradle, aztán majd beosztja, ahogy tudja. Hogy a fél perces build esetleg 8 perc lesz, az már részletkérdés, ugye...
https://iotguru.cloud
Miért van az, hogy linuxon a make 20 évvel ezelőtt, néhány MB RAM-mal, IDE diszkkel is tudta hogy ha a linux kernelben két dolgot átírtál és újrabuildelted akkor max egy perc alatt kész volt az új kernel?
Gábriel Ákos
Az van, hogy megöregedtél... :D
--
Nem volt GUI, nem volt köztes kódhalmaz, nem voltak tesztek, nem voltak UI tesztek, nem volt obfuscator, nem volt architektúra függő optimalizáció, nem volt tree-shaking shrink, nem volt resource shrink, nem volt resource transzformáció, nem volt... kurva sok dolog nem volt. Ezért van az, hogy nem egy 20 évvel ezelőtti Linux kernel fut a telefonon, hanem egy összehasonlíthatatlanul komplexebb rendszer, aminek az optimális és/vagy gyors működéséhez ezek mind kellenek. Igen, lehet mondani, hogy a faszé' van túlbonyolítva, de az a helyzet, hogy pár százalék akkuidőért majdnem embert ölnek, ahhoz meg ezek kellenek. Ha meg vannak, akkor a build lesz lassú, körülményes, problémás, komplex, egyebek és akkor meg kell cache. Ha kell cache, akkor kell memória. És ott vagyunk, ahonnan indultunk.
https://iotguru.cloud
... és vajon ezeket minden egyes "arrébb teszem a gombot 2 pixellel" szintű módosítás után _muszáj_ megcsinálni?
Nem lehetne csak mondjuk egy "prod" build során, a végén?
Szerintem nem csak én "öregedtem meg" hanem a nagy rohanásban egy csomó igénytelen félmegoldás szabadul rá a világra.
Ami lehetne jó is ha egy kicsit még foglalkoznának vele.
Gábriel Ákos
Nincs olyan, hogy A prod build. Terjesztett verzióból is van ezerféle, A/B tesztelés miatt, eltérő platformok miatt (már architektúra), eltérő képernyőméretek miatt. Csinálhatsz külön binárist mindegyik platformra szabva https://developer.android.com/training/multiple-apks/screensize, de csinálhatsz App Bundle-t, amiből majd a Google csinál APK-t, de ez helyi tesztelésre ugye irreleváns: https://developer.android.com/guide/app-bundle .
De ugyanígy multiple apk lehet API szintenként: https://developer.android.com/training/multiple-apks/api
Ez mind megsokszorozza azt, hogy mi az, hogy "prod build". Sőt, igazából a prod buildet maga a Google készíti, te csak odaadsz neki mindent. De ez helyi tesztelésnél irreleváns, ott neked kell ezt megoldanod, hogy keletkezzen minden eszközre optimalizált APK (ez főleg ott érdekes, amikor gyengébb eszközön is akarsz tesztelni).
Régen sem volt ez másként, nem volt olyan, hogy A prod kernel. Van egy vanilla kernelfa, amiből aztán mindenki csiszolt magának egyet, és abból lett a build. Hány és hány ezer óra ment el azzal, hogy mindenki magának buildelt kernelt pármillió gépen? Ha összeadnánk, nem jönne ki kis szám. Nos, most ezt csinálja meg a fejlesztő egymaga.
Ha ott van a cache-ben, akkor nyilván nem. Ha nincs ott, mert nincs elég heap a build során, akkor meg nyilván muszáj megcsinálni.
Igen, könnyen lehet, hogy a Google ezzel foglalkozó mérnökei mind balfaszok és a közösségből sincs egyetlen értő ember sem, aki küldene patch, ha már nyílt forrású az egész. Mondjuk én látok egy kevés esélyt arra is, hogy ez tényleg ennyire komplex lett.
https://iotguru.cloud
> Igen, könnyen lehet, hogy a Google ezzel foglalkozó mérnökei mind balfaszok és a közösségből sincs egyetlen értő ember sem, aki küldene patch, ha már nyílt forrású az egész.
A nyílt forrás arra jó, hogy ha van egy bug, akkor azt ki tudja javítani aki megtalálja. Azonban alapvető tervezési szintű problémákat nem lehet így megoldani, mert aki átalakítaná az mindent fel kellene, hogy forgasson, és már inkább akkor ír egy újat.
Hogy mondjak egy konkrét példát: amikor Java-t buildelünk, akkor a folyamat valami ilyesmi - jócskán egyszerűsítve:
* Források parszolása
* Függőségek betöltése
* fordítás
* És ennek az ismételgetése fordítás egységenként, amit bundle, modul, satöbbi néven szokás nevezni.
Ha van egy sok fordítási egységből álló projekt, akkor ezeket ismételgeti a rendszer fordítási egységenként. Miközben a függőségek jelentős része ugyanaz, ráadásul legtöbbször a függőség az, amit éppen az előbb fordított le a rendszer. Tehát felesleges volna újratölteni, de a build rendszerek megteszik. Hiába van még esetleg benn a memóriában az adott függőség, mivel a fordítót modulonként újraparaméterezve indítjuk, nem lesz lehetősége újrahasznosítani a betöltött dolgokat. A cache-ben persze benne lesz a fájl, gyorsabb lesz betölteni, de a munka jelentősebb része a fájl értelmezése és ez alapján a publikus interfészek szerkezetének, keresőfáknak satöbbiknek a felépítése. Ezt mindig újra kell csinálni.
Az Eclipse beépített buildere egyébként úgy tud működni, hogy egyetlen fordító objektumban dolgozza fel az összes modult, a fordítás köztes eredményeit memóriában tartja, és valóban inkrementálisan tud működni, ezért meg tudja azt csinálni, hogy ctrl-s után egyetlen pillanattal (saccra 1s-nél rövidebb idő alatt) már az új kód indítható, vagy nyitott debug session esetén már automatikusan aktiválva is van. (Kivétel csak az amikor egy óriás projektben a függőségi fa gyökerénél változtatunk, akkor is gyors, de akkor lehet néhány másodperc is a fordítás.) Aztán ugyanazokat a bundle-ket parancssorból fordítani sok perces tortúra. És ha Maven vagy gradle projekt van Eclipse alatt, nem a saját natív formátuma, akkor megintcsak lassú lesz (ez régebbi tapasztalatom, de nem vagyok szakértő ebben), ezért mondják a userek, hogy az Eclipse lassú, miközben én annyira gyorsnak tapasztalom, hogy érzésre 0 idő alatt van meg a legtöbb build.
Projektenkénti (bundle, modul stb, sokféle neve van) ismételgetés helyett meg lehet csinálni azt, hogy egyszerre töltünk be és fordítunk mindent. És ez a megoldás valóban sokszor gyorsabb. Csak éppenséggel az egész build logikája teljesen más, nem is nagyon lehet iteratív lépéseken keresztül a meglévő megoldásokon keresztül elérni, eleve így kell nekiállni. Egy-két összetett projekten játékból összeraktam ilyen parancssori buildet, ami egy lépésben fordít sok modult (ami annyi, hogy összegereblyézzük a források és függőségek listáját és direkben meghívjuk a például a javac parancsot - ezt manapság a legtöbb Java fejlesztő el sem tudja képzelni, pedig még mindig működik csak akarni kell), és valóban sokkal gyorsabb lett, de már nincsenek meg a számaim.
A példát azért hoztam fel, hogy nagyon nem mindegy, hogy hogyan van megtervezve a build folyamata, és ha már az elv lassú, akkor abból nem lehet optimalizálgatással gyorsat csinálni, csak gyökeres átalakítással.
Közben picit utánanéztem a gradle doksinak. Elég sok mindent lehet hangolni rajta, valszeg a kérdező is simán tudna csökkenteni a memória igényén.
Hogy a mobil fejlesztéshez miért kell ennyi erőforrás azt továbbra se "érzem" de nem is értek hozzá és nem is érdekel :)
Gábriel Ákos
Oké, feladom, hangolni kell.
https://iotguru.cloud
Hány soros volt 20 évvel ezelőtt a kernel, és mennyi ma? Mennyi dolgot csinált akkor a fordító (mennyire volt okos), és mit csinál ma?
A Gradle az diszkre írást helyettesít memóriával, ettől lesz gyors. Nem értem a problémádat.
ez jó :)
Valaki nyomatta nálunk a gradlet. Örülök hogy befulladt.
Az egész gradle ötlete egy szivárgó absztrakciónak tűnik nekem. Mi köze a buildnek ahhoz, hogy ssd van alatta, hdd, vagy szalag? Az egész egy non-issue. Ram diszket kell alarakni aztán bármiből gradle lesz.
Nyilván az üzemeltetői szempontok is fontosak, de build engineer/fejlesztői szempontok is ugyanúgy. Make, Ant/Ivy, Maven, Gradle, mind ugyanarra a problémakörre adnak eltérő megoldást, eltérő szemlélettel:
Van olyan project, ahol kínszenvedés nekem pl a Maven használata, de azt kell, és kész. Cserébe írhattam rá plugint, hostolhattam Nexus/Artifactory/whateverben, csinálhattam rá pipeline-t. Ugyanezt Gradle-ből pár sor alatt elintéztem volna.
Más esetben pedig végülis mégiscsak jó egy "jól bevált" Antot indítani Mavenből. Kivéve, amikor Mavenből indítok egy Antot, hogy indítsak belőle egy Mavent...
De pl Gradle-ben nincsen archetype support, ami meg párszor jól jönne.
Szóval szerintem projectje válogatja, mi az optimális. És persze itt még nem beszéltünk az npm-ről, és a több nyelvű supportjáról.
Ezt nem így szokás errefelé. Válaszd ki, amelyik neked tetszik, kommenteld oda mindenhova, a többit pedig fikázd le. :)