Android build tools ఇప్పుడు Kotlin Coroutines కోసం వేగాన్ని పెంచాయి. Android Gradle Plugin (AGP) 9.2.0 మరియు దానితో పాటు వచ్చే R8 shrinker ద్వారా, coroutine state handling కోసం ఉపయోగించే bytecode ఇప్పుడు తిరిగి రాయబడింది (rewritten), దీనివల్ల సాధారణ coroutine ఆపరేషన్లలో దాదాపు రెట్టింపు పనితీరు లభిస్తుంది. Coroutines పై ఆధారపడే Android యాప్‌లను డెవలప్ చేసేవారు, ఒక్క లైన్ Kotlin కోడ్‌ను కూడా మార్చకుండానే వేగవంతమైన cold-start times, స్థిరమైన frame rates మరియు బ్యాటరీ లైఫ్‌లో మెరుగుదలను చూడవచ్చు.

Coroutine పనితీరు ఎందుకు ముఖ్యమైనది

Kotlin Coroutines బహుళ థ్రెడ్‌ల నుండి అంతర్గత ఫీల్డ్‌లను సురక్షితంగా మార్చడానికి AtomicFieldUpdater ఆబ్జెక్ట్‌లను ఉపయోగిస్తాయి. ఈ విధానం ప్రతి అప్‌డేట్‌కు కొత్త atomic ఆబ్జెక్ట్‌ను కేటాయించడాన్ని నివారిస్తుంది, కానీ Androidలో ఇది మూడు దాగి ఉన్న ఖర్చులను (costs) కలిగిస్తుంది:

  • Class-loading delay – updater రిఫ్లెక్టివ్‌గా (reflectively) సృష్టించబడుతుంది, కాబట్టి VM రన్‌టైమ్‌లో టార్గెట్ ఫీల్డ్‌ను వెతకాల్సి ఉంటుంది.
  • CPU waste – ప్రతి యాక్సెస్ అసలు ఫీల్డ్‌కు చేరుకోకముందే updater యొక్క స్థితిని తనిఖీ చేస్తుంది.
  • Inlining limits – కంపైలర్ updater కాల్స్‌ను inline చేయలేదు, దీనివల్ల జనరేట్ చేయబడిన bytecode పెద్దదిగా మరియు నెమ్మదిగా ఉంటుంది.

ఆచరణలో, ఈ ఖర్చులు channel send/receive, mutex lock/unlock, StateFlow updates మరియు coroutine dispatch వంటి hot paths లలో కనిపిస్తాయి. దీని ఫలితంగా, యాప్ యొక్క స్వంత పని కంటే బుక్‌కీపింగ్ (bookkeeping) పైనే ఎక్కువ CPU సమయం వృథా అవుతుంది.

AGP 9.2.0 మరియు R8లో ఏ మారింది

AGP 9.2.0తో వచ్చే కోడ్-ష్రింకర్ (code-shrinker) అయిన R8, ఇప్పుడు కంపైల్ చేయబడిన bytecodeలో స్టాండర్డ్ AtomicFieldUpdater ప్యాటర్న్‌ను స్కాన్ చేస్తుంది. అది ఒక ప్యాటర్న్‌ను కనుగొన్నప్పుడు, నాలుగు మార్పులను (transformations) చేస్తుంది:

  1. ఫీల్డ్ యొక్క మెమరీ ఆఫ్‌సెట్‌ను గుర్తించడం (Identify the field’s memory offset): ఆబ్జెక్ట్ లేఅవుట్‌లో టార్గెట్ ఫీల్డ్ యొక్క ఖచ్చితమైన స్థానాన్ని R8 లెక్కిస్తుంది.
  2. Updater ఆబ్జెక్ట్‌ను తొలగించడం (Drop the updater object): రిఫ్లెక్టివ్ రాపర్ (reflective wrapper) తొలగించబడుతుంది, దీనివల్ల మెమరీ ఆదా అవుతుంది మరియు class-loading పని తగ్గుతుంది.
  3. నేరుగా sun.misc.Unsafe కాల్‌ను చేర్చడం (Insert a direct sun.misc.Unsafe call): ఈ లో-లెవల్ API ఒకే అటామిక్ హార్డ్‌వేర్ ఇన్‌స్ట్రక్షన్ ఉపయోగించి ఫీల్డ్‌లోకి రాస్తుంది.
  4. ప్రతి updater కాల్‌ను మార్చడం (Replace every updater call): కొత్త unsafe ఇన్‌స్ట్రక్షన్‌తో ప్రతి అప్‌డేట్‌ను మార్చడం ద్వారా, JIT కంపైలర్ ఆ ఆపరేషన్‌ను inline చేయగలుగుతుంది.

దీని వల్ల కలిగే ఫలితం ఏమిటంటే, CPU ఇకపై రిఫ్లెక్టివ్ లుకప్ లేదా రన్‌టైమ్ తనిఖీలు చేయనవసరం లేదు; అది అటామిక్ ఇన్‌స్ట్రక్షన్‌ను నేరుగా అమలు చేస్తుంది. డెవలపర్ దృక్కోణంలో ఈ మార్పు కనిపించదు – coroutine API ఒకేలా పనిచేస్తుంది – కానీ లోపల కోడ్ "metal-level" వేగంతో నడుస్తుంది.

కొలవదగిన లాభాలు

AGP 9.2.0తో బిల్డ్ చేసి, R8 ఎనేబుల్ చేసి, minification ఆన్ చేసిన తర్వాత, సాధారణ Android పరికరంలో బెంచ్‌మార్క్‌లు ఈ క్రింది వేగపు పెరుగుదలను చూపుతున్నాయి:

  • Channel send/receive: 2.01 × వేగంగా
  • Mutex lock/unlock: 1.90 × వేగంగా
  • StateFlow updates: 2.02 × వేగంగా
  • Coroutine dispatch: 1.68 × వేగంగా

ఈ సంఖ్యలు వాస్తవమైన యూజర్-ఎక్స్‌పీరియన్స్ మెరుగుదలలకు దారితీస్తాయి. Coroutine synchronisation కోసం సెకనులో కొంత భాగం వేచి ఉండే cold launch ఇప్పుడు త్వరగా పూర్తవుతుంది, దీనివల్ల మొదటి ఫ్రేమ్‌ను రెండర్ చేయడానికి UI థ్రెడ్‌కు ఎక్కువ సమయం లభిస్తుంది. CPU contention తగ్గడం వల్ల ప్రాసెసర్ త్వరగా స్లీప్ మోడ్‌లోకి వెళ్లగలదు, ఇది బ్యాటరీ లైఫ్‌ను మెరుగుపరుస్తుంది.

ఈ ప్రయోజనాన్ని ఎలా పొందాలి

కోడ్ మార్పులు ఏవీ అవసరం లేదు. ఈ మార్పును అమలు చేయడానికి మీకు ఇవి అవసరం:

  • AGP 9.2.0 లేదా అంతకంటే కొత్తది – అప్‌డేట్ చేయబడిన R8 ఉన్న వెర్షన్.
  • R8 – పైన పేర్కొన్న AGPతో బిల్డ్ చేసినప్పుడు ఆటోమేటిక్‌గా ఉపయోగించబడుతుంది.
  • Kotlin Coroutines 1.8.0+ – ఆప్టిమైజర్ ఆశించే AtomicFieldUpdater ప్యాటర్న్‌తో వచ్చే లైబ్రరీ వెర్షన్.
  • మీ release build typeలో isMinifyEnabled = true – minification ఆన్ చేసినప్పుడు మాత్రమే R8 రన్ అవుతుంది.

మీరు చేయవలసిన ఏకైక అదనపు పని మీ ProGuard (లేదా R8) రూల్స్‌ను తనిఖీ చేయడం. Volatile ఫీల్డ్‌లను లేదా updater క్లాస్‌లను అలాగే ఉంచే విస్తృతమైన -keep డైరెక్టివ్‌లు ఈ మార్పును అడ్డుకుంటాయి. ఆ ఫీల్డ్‌లను R8 మార్చడానికి అనుమతించేలా రూల్స్ ఉండేలా చూసుకోండి; లేకపోతే ఆప్టిమైజర్ తిరిగి పాత రిఫ్లెక్టివ్ ఇంప్లిమెంటేషన్‌కే వెళ్తుంది.

మీరు Android Studio యొక్క APK Analyzerతో ఈ మార్పును ధృవీకరించవచ్చు. కంపైల్ చేయబడిన APKని ఓపెన్ చేసి, JobSupport వంటి coroutine సపోర్ట్ క్లాస్‌ను గుర్తించి, డీకంపైల్ చేయబడిన bytecodeను పరిశీలించండి. ఒకవేళ ఈ మార్పు విజయవంతమైతే, static updater ఫీల్డ్‌లు ఉండవు మరియు వాటికి బదులుగా Unsafe కి నేరుగా కాల్స్ కనిపిస్తాయి.

హెచ్చరికలు మరియు ఇతర అంశాలు

ఈ ఆప్టిమైజేషన్ ప్రతి ప్రాజెక్ట్‌కు వర్తించని రెండు షరతులపై ఆధారపడి ఉంటుంది:

  1. Minification తప్పనిసరిగా ఎనేబుల్ చేయాలి. డీబగ్గింగ్ సౌలభ్యం కోసం minification ని ఆపివేసిన debug builds లేదా release builds ఈ ప్రయోజనాన్ని పొందలేవు.
  2. ProGuard rules అనుమతించే విధంగా (permissive) ఉండాలి. coroutine internals కోసం కఠినమైన -keep ప్యాటర్న్స్‌ను ఉపయోగించే ప్రాజెక్ట్‌లు ఆ నియమాలను సడలించాల్సి రావచ్చు, దీనివల్ల జాగ్రత్తగా పరీక్షించకపోతే internal classes, shrinking-కి సంబంధించిన బగ్స్‌కు గురయ్యే అవకాశం ఉంది.

మీరు లక్ష్యంగా చేసుకున్న వివిధ రకాల పరికరాలపై పరీక్షించడం మంచి పద్ధతి.

తదుపరి ఏమి గమనించాలి

భాషా అబ్‌స్ట్రాక్షన్స్ (language abstractions) వెనుక దాగి ఉన్న పనితీరును, build-time bytecode transformations ఎలా వెలికితీయగలవో ఈ రీరైట్ చూపుతుంది. మీ నిర్దిష్ట వర్క్‌లోడ్‌పై (workload) ఈ లాభాలను ధృవీకరించుకోవడానికి, మీ coroutine-heavy కోడ్‌ను ప్రొఫైలింగ్ (profiling) చేయండి.

ముఖ్య గమనిక: AGP 9.2.0 కి అప్‌గ్రేడ్ చేయడం మరియు R8 minification ని ఎనేబుల్ చేయడం వల్ల, సోర్స్ కోడ్‌ను మార్చకుండానే, Kotlin coroutine-heavy యాప్‌ల యొక్క కీలకమైన synchronization వేగం దాదాపు రెట్టింపు అవుతుంది—అయితే బిల్డ్ కాన్ఫిగరేషన్ ఆప్టిమైజర్ (optimizer) తన పనిని చేయడానికి అనుమతించాలి.