# Xcode-ის ქეში {#xcode-cache}

Tuist უზრუნველყოფს Xcode-ის კომპილაციის ქეშის მხარდაჭერას, რაც გუნდებს საშუალებას აძლევს გაუზიარონ ერთმანეთს კომპილაციის არტეფაქტები ბილდის სისტემის ქეშირების შესაძლებლობების გამოყენებით.

Xcode-ის ქეში წარმოდგენილი იყო Xcode 26-ში. მას ასევე შეგიძლიათ შეხვდეთ როგორც Xcode-ის ბილდის ქეშს; ის ხელახლა იყენებს კომპილაციის არტეფაქტებს, რომლებიც დაკავშირებულია მათ შემავალ მონაცემებთან, ხოლო Tuist-ის დისტანციური ქეში ამ არტეფაქტებს მანქანებს შორის გაზიარებადს ხდის. იმის შესახებ, თუ როგორ არის ის დაკავშირებული DerivedData-სთან და Clang-ის მოდულის ქეშთან, იხილეთ <.localized_link href="/references/concepts/build-cache#xcode">რა არის Xcode-ის ქეშები?</.localized_link>. იმის გასარკვევად, თუ ნელი ბილდის რომელ ნაწილს აშორებს ქეში და რა უნდა გამოსწორდეს პროექტში პირველ რიგში, იხილეთ [ნელი ბილდები](https://tuist.dev/solutions/slow-builds).

> [!TIP]
> **გააერთიანეთ მოდულის ქეშთან**
>
> Xcode-ის ქეში და <.localized_link href="/guides/features/cache/module-cache">მოდულის ქეში</.localized_link> მუშაობენ სხვადასხვა დეტალიზაციის დონეზე და ერთმანეთს ავსებენ. მოდულის ქეში ბილდის გაშვებამდე მთლიან მოდულებს ცვლის წინასწარ აწყობილი `.xcframework`-ებით, ხოლო Xcode-ის ქეში ბილდის დროს ხელახლა იყენებს კომპილაციის შედეგებს.

> [!TIP]
> **დეველოპერის მანქანებზე, გაწმენდისას შეინახეთ `CompilationCache.noindex`**
>
> ნაგულისხმევად, კომპილაციის ქეშის საცავი მდებარეობს `DerivedData`-ის შიგნით, ამიტომ `DerivedData`-ის წაშლა მასთან ერთად შლის ბილდის პროდუქტებსაც. დეველოპერის მანქანაზე უმჯობესია წაშალოთ მხოლოდ ბილდის პროდუქტები: ხელახალი ბილდი მაშინ დისკზე არსებული საცავიდან აღდგება, ყოველგვარი ჩამოტვირთვის გარეშე.

## მოწყობა {#setup}

თუ ჯერ არ გაქვთ Tuist-ის ანგარიში და პროექტი, შეგიძლიათ შექმნათ შემდეგი ბრძანების გაშვებით:

```bash
tuist init
```

როდესაც გექნებათ `Tuist.swift` ფაილი, რომელიც მიუთითებს თქვენს `fullHandle`-ზე, შეგიძლიათ მოაწყოთ ქეშირება თქვენი პროექტისთვის შემდეგი ბრძანების გაშვებით:

```bash
tuist setup cache
```

ეს ბრძანება ქმნის [LaunchAgent](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPSystemStartup/Chapters/CreatingLaunchdJobs.html)-ს, რათა გაუშვას ლოკალური ქეშის სერვისი გაშვებისას, რომელსაც Swift-ის [ბილდის სისტემა](https://github.com/swiftlang/swift-build) იყენებს კომპილაციის არტეფაქტების გასაზიარებლად. თავდაპირველად გაუშვით ის თქვენს დეველოპერულ მანქანაზე და CI-ის თითოეული სამუშაოს მოწყობის ნაწილად.

CI-ზე ქეშის მოსაწყობად დარწმუნდით, რომ ხართ <.localized_link href="/guides/server/authentication#continuous-integration">ავტორიზებული</.localized_link>.

### ქეშის კომპონენტების განახლება {#updating-the-cache-components}

ქეშის პროქსი იყენებს სტაბილურ გამშვებს და არა გზას, რომელიც მიბმულია Tuist-ის ინსტალაციაზე, რომელმაც ბოლოს გაუშვა მოწყობა. ინსტალაციის შემდეგ, `tuist setup cache` და ქეშით აღჭურვილი `tuist generate` გადაჰყავს გამოყენებად მიზანს Tuist-ის უფრო ახალ ვერსიებზე. პროექტები, რომლებიც მიბმულია Tuist-ის ძველ ვერსიაზე, არ ამცირებენ საერთო პროქსის ვერსიას. გენერაცია მხოლოდ ანახლებს არსებულ გამშვებ მიზანს: ის არ აინსტალირებს სერვისს, არ ახდენს ავტორიზაციას, არ ცვლის პლაგინს და არ ა重新启动ებს პროქსის. პლაგინის, პროქსის, სოკეტის ან რეესტრის მორგებული გადაფარვები ტოვებენ ავტომატურ განახლებას.

მოქმედი პროქსი იღებს ახალ მიზანს მხოლოდ მაშინ, როდესაც ქეშის მოთხოვნების გარეშე გადის მინიმუმ 30 წამი, არ არის მოთხოვნები ან ფონური სამუშოები პროცესში და მისი გამოქვეყნების რიგები დაცლილია. შემდეგ ის ტოვებს პროცესს და launchd იწყებს შერჩეულ CLI-ს, ინარჩუნებს სერვისის არგუმენტებს და სერთიფიკატების გარემოს. მხოლოდ ის პროქსი, რომელიც რეალურად იღებს მიზანს, ატომურად ანახლებს დისკზე არსებულ პლაგინს მისი ბანდიდან; მოწყობა არ აინსტალირებს უფრო ახალ პლაგინს, სანამ ძველი პროქსი ჯერ კიდევ ცლის რიგებს. თუ ინსტალირებული პლაგინი არ არის, ცალსახა მოწყობა უქმედობის რეჟიმში ა重新启动ებს შერჩეულ პროქსის განახლების ხელახალი ცდისთვის. კვლავ მხოლოდ ერთი პროქსი ფლობს რეესტრს და რიგებს. მიუწვდომელი მიზანი ან დაუცლელი ატვირთვები გადადებს გადართვას აქტიური მოთხოვნების შეწყვეტის ნაცვლად. სერთიფიკატების განახლება მიჰყვება შერჩეულ CLI-ს გადართვამდეც კი, ამიტომ ძველი CLI ინსტალაციის წაშლა არ ტოვებს ატვირთვებს დაუცლელ მდგომარეობაში.

არსებულ ინსტალაციას, რომელიც შექმნილი იყო სტაბილური გამშვების წინ, სჭირდება ერთი ცალსახა მიგრაცია. გაუშვით შემდეგი, როდესაც არცერთი ბილდი არ არის გაშვებული:

```bash
tuist setup cache
```

ამ მიგრაციის შემდეგ, Tuist-ის განახლება და ჩვეულებრივი `tuist generate`-ის გაშვება საკმარისია პროქსისა და ინსტალირებული პლაგინის განახლებისთვის; თქვენ არ გჭირდებათ მოწყობის ხელახლა გაშვება CLI-ის თითოეული ვერსიისთვის. ცალსახა მოწყობა კვლავ საჭიროა სხვა Xcode-ის არჩევისთვის, მათ შორის იმავე გზაზე განახლებული Xcode-ისთვის. მოწყობას შეუძლია ჩაანაცვლოს საერთო სერვისი, როდესაც მისი კონფიგურაცია იცვლება, ამიტომ ჯერ დაელოდეთ მანქანაზე ყველა ბილდის დასრულებას. პროქსი მხარდაჭერს წინა პლაგინის პროტოკოლსაც და მიმდინარესაც, ამიტომ Xcode-ში უკვე ჩატვირთული თავსებადი პლაგინი განაგრძობს მუშაობას პროქსის განახლების შემდეგაც. სრულად დახურეთ და ხელახლა გახსენით Xcode უახლესი პლაგინის ჩატვირთვისთვის, მაგრამ თავსებად ჩატვირთულ პლაგინს არ სჭირდება დაუყოვნებლივი გადატვირთვა. ხელახლა შექმენით პროექტები, როდესაც ვერსია ცვლის გენერირებულ ბილდის პარამეტრებს.

შეინახეთ შერჩეული Tuist-ის ინსტალაცია ხელმისაწვდომი: გამშვები იყენებს მას გაშვების, კონფიგურაციისა და სერთიფიკატების განახლებისთვის. ძველი ინსტალაციების წაშლა შესაძლებელია, როდესაც გამშვები განახლდება. თუ შერჩეული შესრულებადი ფაილი წაიშალა ან აღარ არის შესრულებადი, `tuist setup cache` შეუძლია აღადგინოს მიზანი ხელმისაწვდომი ინსტალაციის გამოყენებით, თუნდაც ძველი ვერსიის, ქეშის ჯერ დემონტაჟის გარეშე. სტაბილური შესრულებადი ფაილების ალიასები ინარჩუნება პაკეტის მენეჯერის განახლებების დროს; სიმბოლური ბმულები იხსნება მხოლოდ ინსტალაციის იდენტურობის შედარებისას. გაშვებისას პროქსი იწერს რეალურად გაშვებულ ვერსიას, მათ შორის ადგილზე განახლებებს ან განზრახ დაბრუნებებს, თან ინარჩუნებს უმაღლეს გამოყენებულ ვერსიას, რათა თავიდან აიცილოს არარელევანტური ძველი ჩეკაუტების მიერ გამოყენებადი ინსტალაციის გადართვა.

წყაროდან აწყობილი CLI-ები რელიზის ვერსიის გარეშე და ცალსახა `TUIST_CAS_PLUGIN_PATH` ან `TUIST_CAS_PROXY_PATH` მოწყობები იყენებენ ცალსახა გაშვების კონფიგურაციას ავტომატური ვერსიის შერჩევის ნაცვლად. ხელახლა გაუშვით მოწყობა ამ კომპონენტების ხელახალი აწყობის შემდეგ. მოწყობა ამოწმებს მათ აქტუალურობას და თიშავს მართვადი მიზნის განახლებას მხოლოდ მაშინ, როდესაც მისი ჩამნაცვლებელი მზად არის.

`tuist teardown cache` აჩერებს სერვისს გამშვები მიზნის წაშლამდე, თან ინარჩუნებს სტაბილურ პლაგინს არსებული პროექტებისთვის. თუ სერვისის გაჩერება ვერ ხერხდება, მისი გამშვები რჩება ხელმისაწვდომი გადატვირთვისა და დემონტაჟის კიდევ ერთი ცდისთვის. გენერაცია ვერ აღადგენს სერვისს წარმატებული დემონტაჟის შემდეგ.

### Xcode-ის ბილდის პარამეტრების კონფიგურაცია {#configure-xcode-build-settings}

არსებული Xcode-ის პროექტისთვის, დააკოპირეთ `tuist setup cache`-ის მიერ დაბეჭდილი ბილდის პარამეტრები თქვენი პროექტის Build Settings-ში ან არსებულ `.xcconfig` ფაილში. ბრძანება ბეჭდავს კონფიგურაციას თქვენი ანგარიშისთვის; ის არ ქმნის კონფიგურაციის ფაილს და არ ასწორებს თქვენს Xcode-ის პროექტს. შეინახეთ `$(inherited)`, როდესაც აფართოებთ `OTHER_SWIFT_FLAGS`-ს, რათა სხვა კომპილატორის პარამეტრები შენარჩუნდეს.

პარამეტრები მოიცავს:

```
COMPILATION_CACHE_ENABLE_CACHING = YES
COMPILATION_CACHE_ENABLE_PLUGIN = YES
COMPILATION_CACHE_PLUGIN_PATH = $HOME/.local/state/tuist/libtuist_cas_plugin.dylib
COMPILATION_CACHE_REMOTE_SERVICE_PATH = $HOME/.local/state/tuist/cas-proxy.sock
COMPILATION_CACHE_ENABLE_DETACHED_KEY_QUERIES = YES
COMPILATION_CACHE_ENABLE_DIAGNOSTIC_REMARKS = YES
OTHER_SWIFT_FLAGS = $(inherited) -cas-plugin-option tuist-instance=your-org/your-project
```

გაითვალისწინეთ, რომ `COMPILATION_CACHE_ENABLE_PLUGIN`, `COMPILATION_CACHE_PLUGIN_PATH`, `COMPILATION_CACHE_REMOTE_SERVICE_PATH` და `COMPILATION_CACHE_ENABLE_DETACHED_KEY_QUERIES` უნდა დაემატოს როგორც **მომხმარებლის მიერ განსაზღვრული ბილდის პარამეტრები**, რადგან ისინი პირდაპირ არ არის ხელმისაწვდომი Xcode-ის ბილდის პარამეტრების UI-ში.

> [!NOTE]
> **პლაგინის გზა**
>
> `libtuist_cas_plugin.dylib` არის კომპილაციის ქეშის პლაგინი, რომელიც მოყვება Tuist-ს `tuist` შესრულებადი ფაილის გვერდით. `tuist setup cache` აკოპირებს მას `$HOME/.local/state/tuist/libtuist_cas_plugin.dylib`-ში და `COMPILATION_CACHE_PLUGIN_PATH` მიუთითებს ამ ასლზე. გზა იგივეა ყველა მანქანაზე და არ იცვლება Tuist-ის განახლებისას, ამიტომ შეგიძლიათ ეს პარამეტრი პროექტთან ერთად შეინახოთ რეპოზიტორიაში. Setup და ახლად გაშვებული პროქსი ანახლებენ ასლს შერჩეული Tuist ბანდლიდან; ძველი ჩეკაუტიდან setup-ის გაშვება არ ამცირებს უფრო ახალი პლაგინის ვერსიას.

> [!NOTE]
> **ერთი სოკეტი თითოეული პროექტისთვის**
>
> `tuist setup cache` აყენებს ერთ ქეშის პროქსს თითოეულ მანქანაზე, ამიტომ ყველა პროექტი იყენებს ერთსა და იმავე `COMPILATION_CACHE_REMOTE_SERVICE_PATH`-ს. `tuist-instance` პლაგინის პარამეტრი არის ის, რაც პროექტს აიდენტიფიცირებს.

> [!IMPORTANT]
> **`COMPILATION_CACHE_REMOTE_SERVICE_PATH` არის ის, რაც C-ს და Objective-C-ს აზიარებს**
>
> მარტივია ამ პარამეტრის აღქმა როგორც „სად ცხოვრობს ქეშის სერვისი“ და მისი განხილვა როგორც არასავალდებულოს. ის ასევე არის გადამრთველი, რომელიც გადაწყვეტს, აზიარდება თუ არა საერთოდ C, Objective-C, წინასწარ კომპილირებული მოდულები და წინასწარ კომპილირებული ჰედერები: ბილდის სისტემა მხოლოდ მაშინ ახორციელებს მათთვის ქეშირებას, როდესაც დაკონფიგურირებულია დისტანციური ქეშის სერვისი. თუ გამოტოვებთ მას, Swift-ის კომპილაციები მაინც გაზიარდება, მაგრამ ყველა C/Objective-C ფაილი და ყველა მოდული ხელახლა კომპილირდება ნებისმიერ მანქანაზე, რომელსაც აქამდე არ აუწყობია ეს პროექტი.

> [!NOTE]
> **პარალელური ქეშის ძიებები**
>
> `COMPILATION_CACHE_ENABLE_DETACHED_KEY_QUERIES` ასრულებს დისტანციურ ქეშის ძიებებს, რომლებსაც ბილდის სისტემა აკეთებს თითოეული კომპილაციისთვის, ბილდის დანარჩენ პროცესთან ერთად, ნაცვლად იმისა, რომ რამდენიმე ერთდროულად შესრულდეს ბილდის შესრულების არხებზე. ბილდები, რომლებიც ბევრ კომპილაციას ტოვებენ ან აღადგენენ შორეული ქეშიდან, უფრო სწრაფად სრულდება.

ასევე შეგიძლიათ მიუთითოთ ეს პარამეტრები `xcodebuild`-ის გაშვებისას შემდეგი ფლაგების დამატებით, მაგალითად:

```
xcodebuild build -project YourProject.xcodeproj -scheme YourScheme \
    COMPILATION_CACHE_ENABLE_CACHING=YES \
    COMPILATION_CACHE_ENABLE_PLUGIN=YES \
    COMPILATION_CACHE_PLUGIN_PATH=$HOME/.local/state/tuist/libtuist_cas_plugin.dylib \
    COMPILATION_CACHE_REMOTE_SERVICE_PATH=$HOME/.local/state/tuist/cas-proxy.sock \
    COMPILATION_CACHE_ENABLE_DETACHED_KEY_QUERIES=YES \
    COMPILATION_CACHE_ENABLE_DIAGNOSTIC_REMARKS=YES \
    'OTHER_SWIFT_FLAGS=$(inherited) -cas-plugin-option tuist-instance=your-org/your-project'
```

> [!NOTE]
> **პრეფიქსების მეპინგი Xcode 27-ზე და უფრო ახალ ვერსიებზე**
>
> Xcode 27-ზე და უფრო ახალ ვერსიებზე, `tuist setup cache` ასევე ბეჭდავს `SWIFT_ENABLE_PREFIX_MAPPING`-ს, `SWIFT_ENABLE_PROJECT_PREFIX_MAPPING`-ს, `CLANG_ENABLE_PREFIX_MAPPING`-ს და `CLANG_ENABLE_PROJECT_PREFIX_MAPPING`-ს. ისინი კომპილაციის ქეშის გასაღებებს დამოუკიდებელს ხდიან იმისგან, თუ სად მდებარეობს პროექტი და `DerivedData`. დაამატეთ ისინი როგორც მომხმარებლის მიერ განსაზღვრული ბილდის პარამეტრები. მათი ჩართვა ცვლის ყველა ქეშის გასაღებს, ამიტომ შემდეგი ბილდი ხელახლა ავსებს ქეშს. `tuist generate` აყენებს მათ თქვენთვის, როდესაც `enableCaching` ჩართულია.
>
> კომპილატორი ასევე წერს მეპირებულ გზებს კოდის დაფარვის მონაცემებში და Xcode ვერ ხსნის მათ, ამიტომ დაფარვის ანგარიში გამოტოვებს ყველა წყაროს, რომელიც კომპილირებულია პრეფიქსების მეპინგით. დაბეჭდილი პარამეტრები, `TUIST_PREFIX_MAPPING_FOR_COVERAGE_*` პარამეტრებთან ერთად, თიშავენ პრეფიქსების მეპინგს იმ ბილდებში, რომლებიც აგროვებენ კოდის დაფარვას. `tuist generate` იგივეს აკეთებს. ეს ბილდები მაინც იყენებენ კომპილაციის ქეშს, მაგრამ მათი ქეშის გასაღებები დამოკიდებულია პროექტის და `DerivedData` გზებზე.
>
> როდესაც ამ პარამეტრებს გადასცემთ `xcodebuild`-ს კომანდურ სტრიქონში, ერთმაგი ბრჭყალებში ჩასვით მნიშვნელობები, რომლებიც შეიცავს `$(...)`-ს, როგორც ზემოთ `OTHER_SWIFT_FLAGS`-ის შემთხვევაში. წინააღმდეგ შემთხვევაში, გარსი მათ ცარიელ სტრიქონებად გაშლის და პრეფიქსების მეპინგი გაითიშება:
>
> ```
> xcodebuild build -project YourProject.xcodeproj -scheme YourScheme \
>     'SWIFT_ENABLE_PREFIX_MAPPING=$(TUIST_PREFIX_MAPPING_FOR_COVERAGE_$(CLANG_COVERAGE_MAPPING))' \
>     SWIFT_ENABLE_PROJECT_PREFIX_MAPPING=YES \
>     'CLANG_ENABLE_PREFIX_MAPPING=$(TUIST_PREFIX_MAPPING_FOR_COVERAGE_$(CLANG_COVERAGE_MAPPING))' \
>     CLANG_ENABLE_PROJECT_PREFIX_MAPPING=YES \
>     TUIST_PREFIX_MAPPING_FOR_COVERAGE_=YES \
>     TUIST_PREFIX_MAPPING_FOR_COVERAGE_NO=YES \
>     TUIST_PREFIX_MAPPING_FOR_COVERAGE_YES=NO
> ```

> [!NOTE]
> **გენერირებული პროექტები**
>
> პარამეტრების ხელით დაყენება არ არის საჭირო, თუ თქვენი პროექტი გენერირებულია Tuist-ით.
>
> ამ შემთხვევაში, ყველაფერი, რაც გჭირდებათ, არის `enableCaching: true`-ის დამატება თქვენს `Tuist.swift` ფაილში:
> ```swift
> import ProjectDescription
>
> let tuist = Tuist(
>     fullHandle: "your-org/your-project",
>     project: .tuist(
>         generationOptions: .options(
>             enableCaching: true
>         )
>     )
> )
> ```

### დაფარვა პრეფიქსების მეპინგით {#coverage-with-prefix-mapping}

ნაგულისხმევად, გენერირებული პროექტები თიშავენ პრეფიქსების მეპინგს დაფარვის ბილდებისთვის, რათა Xcode-ის დაფარვის ანგარიშები და `xccov` იმუშაონ. შეგიძლიათ ჩართოთ ის, რათა დაფარვის კომპილაციები გაზიარებადი იყოს სხვადასხვა ჩეკაუტებში:

```swift
let tuist = Tuist(
    project: .tuist(
        generationOptions: .options(
            enableCaching: true,
            coverage: .coverage(prefixMapping: true)
        )
    )
)
```

`TUIST_COVERAGE_PREFIX_MAPPING` გარემოს ცვლადი (`1` ან `0`) ანიჭებს უპირატესობას `prefixMapping`-ს. ეს პარამეტრი მოქმედებს Xcode 27-ზე და უფრო ახალ ვერსიებზე და მოითხოვს `enableCaching`-ს. დაფარვის `tuist test` ატვირთვები მხარს უჭერენ მას: Tuist ზომავს გაშვებას `llvm-cov`-ით, რომელიც კითხულობს წყაროებს მეპირებული გზებით და აბრუნებს მათ თქვენი რეპოზიტორიის ფაილებთან. Xcode-ის საკუთარი დაფარვის ანგარიში და `xccov` მაინც შეიძლება გამოტოვონ ეს წყაროები, ასევე ატვირთვა, რომელიც გადადის შედეგების ბანდლის `xccov` ანგარიშზე, რადგან `llvm-cov` ექსპორტი ვერ მოხერხდა. მეპირებულმა `#filePath` მნიშვნელობებმა ასევე შეიძლება იმოქმედონ ტესტებზე, რომლებიც ფიქსტურებს პოულობენ წყაროს ფაილების მიმართებაში; ნაცვლად ამისა, ფიქსტურები გადაწყვიტეთ explicit runtime ჩეკაუტის გზებით. თუ დაფარვას თავად ამუშავებთ, შეუსაბამეთ თითოეული ინსტრუმენტირებული ბინარი მისი მიზნის `$(TARGET_TEMP_DIR)/compilation-prefix-map.json`-ს, რომელიც ვირტუალურ პრეფიქსებს აბრუნებს ლოკალურ დირექტორიებში. არ გამოიყენოთ ერთი მიზნის რუკა ყველა ბინარისთვის, როდესაც პროექტის მიხედვით მეპინგია ჩართული.

დაფარვის-პრეფიქსის პარამეტრები მონაწილეობენ ბინარული ქეშის და შერჩევითი ტესტირების ჰეშებში, რადგან ისინი აკონტროლებენ დაფარვის არტეფაქტებში ჩაწერილ გზებს. ამ პარამეტრის შეცვლა, ან `TUIST_COVERAGE_PREFIX_MAPPING`-ის სხვანაირად დაყენება, აუქმებს ამ ჰეშებს მაშინაც კი, როდესაც ჩვეულებრივი ბილდებისთვის. შეინარჩუნეთ მნიშვნელობა თანმიმდევრული დეველოპერებსა და CI სამუშაოებს შორის, თუ მათ უნდა გაიზიარონ ბინარული ქეშები და შერჩევითი ტესტირების შედეგები.

### გენერირებული პროექტების დებაგი {#debugging-generated-projects}

აღდგენილ ნატიურ მოდულებს სჭირდებათ დაკავშირებული დებაგის ინფორმაცია, ასევე კომპილაციის ქეშზე წვდომა. Tuist ათბობს Debug და Release მოდულებს dSYM-ებით და თითოეული ნაწილის წყაროს იდენტურობის მეტამონაცემებით, შემდეგ ამოწმებს მეტამონაცემებს მომხმარებლის მიერ განცხადებულ წყაროებთან მიზნის ჩანაცვლებამდე. დაკარგული ან შეუთავსებელი მეტამონაცემები ინარჩუნებს ამ მიზნის წყაროებს. სკრიპტით გენერირებულ `.generated(...)` წყაროებს აქვთ დეკლარაციის თითის ანაბეჭდები და არა ვერიფიცირებადი შინაარსის ჩეკსამები, ამიტომ ეს მიზნები რჩებიან წყაროდან აგებულად და არ იგზავნება ნატიური მოდულის ქეშში. გენერირებული რესურსების აქსესორები რეალური შინაარსის ჩეკსამებით რჩებიან შესაბამისად. მხარდაუჭერელი დებაგის ინფორმაცია ტოვებს დაზარალებული მიზნის გამოქვეყნებას, მაგრამ არ ბლოკავს დაუკავშირებელ პროდუქტებს; წყაროს მუტაცია და გაუქმება მაინც აუქმებს გათბობას. ქეშის ფორმატი იცვლება, ამიტომ ძველი ვერსიებით გათბილ არტეფაქტებს ხელახლა გათბობა სჭირდებათ.

ვერიფიცირებული ჩანაცვლებებისთვის, Tuist ამზადებს წყაროს გადაადგილებებს მომხმარებლის კუთვნილ dSYM UUID plist-ებში და აკავშირებს მხოლოდ დებაგისთვის განკუთვნილ თანმხლებ ფაილებს სტატიკური ქეშირებული კოდისთვის. ის არ გადაწერს ქეშირებულ ბინარებს და არ აყენებს მწარმოებლის წყაროს გზებს LLDB-ის მუდმივ გლობალურ წყაროს რუკაში. explicit debugger initializers და module-loader პარამეტრები რჩებიან ავტორიტეტულად. CI-ზე (როდესაც `CI` ან `JENKINS_URL` არის დაყენებული), სქემის pre-action, რომელიც ამას აკეთებს, გადის ცვლილებების გარეშე, რადგან იქ ტესტებს დებაგერი არ უერთდება. დებაგის სიმბოლოები და წყაროს გადაადგილება არ ასწორებენ წყაროს მიმართებით runtime ფაილზე წვდომას ან ნატიურ Xcode დაფარვის ანგარიშებს; დაფარვის ვარიანტის შერჩევა და LLVM ექსპორტი რჩებიან ცალკე ფუნქციებად.

`enableCaching: true`-ით, Tuist აკონფიგურირებს LLDB წყაროს რუკებს Run და Test მოქმედებებისთვის. როდესაც მოქმედებას აქვს მორგებული LLDB ინიციალიზატორი, Tuist ჯერ ჩაწერს გადაწყვეტილ წყაროს რუკას, შემდეგ კი ასრულებს მორგებულ ინიციალიზატორს, რათა მან გააფართოვოს ან გადაფაროს რუკა. წინააღმდეგ შემთხვევაში, ის ტვირთავს `~/.lldbinit-Xcode`-ს, თუ ფაილი არსებობს, ხოლო თუ არა — ბრუნდება `~/.lldbinit`-ზე, სანამ შეცვლის წყაროს რუკას. ის ტვირთავს მხოლოდ ერთ საწყის ფაილს, აღადგენს მომხმარებლის დებაგერის პარამეტრებს ორმაგი შესრულების გარეშე. ჩანაცვლება შლის ძველ ასახვებს წინა გაშვებებიდან და ანიჭებს უპირატესობას საწყისი ფაილის წყაროს რუკებს; წყაროს რუკის ის ჩანაწერები, რომლებიც უნდა შენარჩუნდეს, განათავსეთ მოქმედების მორგებულ ინიციალიზატორში. სხვა საწყისი პარამეტრები ინახება. Tuist-ის ქეშისთვის სპეციფიკური მოდულის ძებნის გზები, ჩამტვირთავის პარამეტრები და Clang-ის დროშები გამოიყენება შემდეგ და ანიჭებს უპირატესობას მომხმარებლის მნიშვნელობებს ამ პარამეტრებისთვის. საწყისი ფაილის შეცდომები რჩება ხილული, მაგრამ არ აჩერებს მომდევნო ბრძანებების ჩატვირთვას, ხოლო ბრძანებები არ იბეჭდება ექოდ. ეს ინიციალიზატორის შენარჩუნება ვრცელდება მაშინაც, როდესაც Tuist აკონფიგურირებს დებაგინგს ბინარებისთვის, რომლებიც აღდგენილია მოდულის ქეშიდან, მაშინაც კი, თუ `enableCaching` გამორთულია და Xcode-ის ადრეულ ვერსიებზე.

Xcode 27-სა და უფრო ახალ ვერსიებში, გენერირებული პროექტები ტოვებენ Xcode-ის პროექტის მიხედვით პრეფიქსების ასახვებს (`SWIFT_ENABLE_PROJECT_PREFIX_MAPPING` და `CLANG_ENABLE_PROJECT_PREFIX_MAPPING`) გამორთულს, თუ პროექტი მათ არ დააყენებს. მათი პრეფიქსები, როგორიცაა `/^src`, თითოეულ პროექტში სხვადასხვა დირექტორიას აღნიშნავს და LLDB მათ მხოლოდ დებაგირებადი სამიზნის პროექტის მიმართ ათანხებს. წყაროები ნაწილდება სამუშაო სივრცის მასშტაბის პრეფიქსებით: `/^root` Tuist-ის ფესვის დირექტორიისთვის, `/^spm` Swift პაკეტის დროებითი დირექტორიისთვის, ხოლო `/^intermediates` და `/^products` აგების შედეგებისთვის. თითოეული მათგანი თითოეულ პროექტში ერთსა და იმავე დირექტორიას აღნიშნავს, ამიტომ შეჩერების წერტილები მუშაობენ სამუშაო სივრცის ნებისმიერი პროექტის წყაროებში.

Tuist-ის ფესვის გარეთ მყოფი გზები არ ასახავს. პროექტის ქეშის გასაღებები, რომელიც ფესვის გარეთაა, დამოკიდებულია იმაზე, თუ სად არის ის გადმოწერილი, ამიტომ სხვა გადმოწერები და მანქანები ვერ პოულობენ მის ქეშს. იმისთვის, რომ მისი გასაღებები დამოუკიდებელი იყოს გადმოწერის ადგილისგან, ჩართეთ პროექტის მიხედვით ასახვები იმ პროექტის მანიფესტში:

```swift
let checkoutIndependentSettings = Settings.settings(base: [
    "SWIFT_ENABLE_PROJECT_PREFIX_MAPPING": "YES",
    "CLANG_ENABLE_PROJECT_PREFIX_MAPPING": "YES",
])
```

გადაეცით ეს პარამეტრები ამ `Project`-ს. როდესაც სხვა პროექტის სამიზნეს ადებაგებთ, LLDB ვერ პოულობს იმ პროექტის წყაროებს. მანიფესტის პროექტის საბაზისო პარამეტრები ანიჭებენ უპირატესობას პროექტის დონის xcconfig მნიშვნელობებს, ამიტომ დააყენეთ ისინი თავად მანიფესტში.

ამ პარამეტრების შეცვლა ცვლის კომპილაციის ქეშის გასაღებებს, ბინარული ქეშის ჰეშებს და შერჩევითი ტესტირების ჰეშებს, ამიტომ ამ ქეშების ხელახალი „გათბობა“ საჭიროა. შეინარჩუნეთ არჩევანი თანმიმდევრული თქვენს გუნდში.

### ქეშის ატვირთვის პოლიტიკა {#cache-upload-policy}

ნაგულისხმევად, ქეშის სერვისი იწერს და ტვირთავს არტეფაქტებს შორეულ ქეშში. ამის კონტროლი შეგიძლიათ `Tuist.swift` ფაილში `xcodeCache` პარამეტრით, რათა ჩართოთ მხოლოდ წაკითხვის რეჟიმი, სადაც არტეფაქტები იწერება, მაგრამ არასდროს იტვირთება:

```swift
import ProjectDescription

let tuist = Tuist(
    fullHandle: "your-org/your-project",
    xcodeCache: .xcodeCache(
        upload: false
    ),
    project: .tuist(
        generationOptions: .options(
            enableCaching: true
        )
    )
)
```

ჩვეულებრივი პრაქტიკაა არტეფაქტების ატვირთვა მხოლოდ CI-დან, სადაც აგებები განმეორებადია, ხოლო ლოკალური გარემოები რჩება მხოლოდ წაკითხვის რეჟიმში. ამის მიღწევა შეგიძლიათ `Environment.isCI`-ის გამოყენებით, რომელიც ამოწმებს `CI` გარემოს ცვლადს, რომელსაც აყენებს CI-ის უმეტესი პროვაიდერი:

```swift
import ProjectDescription

let tuist = Tuist(
    fullHandle: "your-org/your-project",
    xcodeCache: .xcodeCache(
        upload: Environment.isCI
    ),
    project: .tuist(
        generationOptions: .options(
            enableCaching: true
        )
    )
)
```

ამ კონფიგურაციით, ლოკალური აგებები სარგებლობენ ქეშირებული არტეფაქტებით ატვირთვის გარეშე, ხოლო CI აგებები ავსებენ ქეშს გუნდის დანარჩენი წევრებისთვის.

ატვირთვის პოლიტიკა ფიქსირდება თითოეული პროექტისთვის იმ მანქანაზე, რომელიც ასრულებს `tuist setup cache`-ს. მის შესაცვლელად, განაახლეთ `upload` და კვლავ გაუშვით `tuist setup cache`, ასევე `tuist generate`, თუ Tuist გენერირებს თქვენს პროექტს. ამის შემდეგ ატვირთვები ემორჩილებიან ახალ პოლიტიკას იმ მანქანაზე ქეშის გადატვირთვის გარეშე. ერთსა და იმავე პროექტის სამუშაოები, რომლებიც ერთდროულად მუშაობენ ერთ მანქანაზე, იზიარებენ მის პოლიტიკას, ამიტომ ყველა მათთვის გადაწყვეტილებას იღებს ყველაზე ბოლო `tuist setup cache`.

### საწყობის ზომის ლიმიტი {#store-size-limit}

კომპილაციის ქეშის საწყობი იზრდება ყოველი აგებისას. პროექტის საწყობების შესაზღუდად, დააყენეთ `storeSizeLimit` თქვენს `Tuist.swift` ფაილში:

```swift
import ProjectDescription

let tuist = Tuist(
    fullHandle: "your-org/your-project",
    xcodeCache: .xcodeCache(
        storeSizeLimit: .gigabytes(20)
    ),
    project: .tuist(
        generationOptions: .options(
            enableCaching: true
        )
    )
)
```

Tuist ამოწმებს პროექტის თითოეულ საწყობს, როდესაც მისი ქეშის პროქსი იწყებს მუშაობას, ნებისმიერი აგების გამოყენებამდე, და ყოველ 10 წუთში, როდესაც აგება არ მიმდინარეობს. `tuist setup cache` იწყებს პროქსის მუშაობას, თუ ის არ მუშაობს, ამიტომ CI სამუშაო, რომელიც ასრულებს `tuist setup cache`-ს აგებებამდე და `tuist teardown cache`-ს მათ შემდეგ, ზღუდავს ხანგრძლივად მოქმედი გამშვების საწყობებს ყოველი სამუშაოს დასაწყისში. ის შლის საწყობის უძველეს ქეშირებულ შედეგებს, როდესაც ახალმა აგებებმა ჩაწერეს ლიმიტის დაახლოებით ნახევარი, ამიტომ საწყობი სტაბილიზდება ლიმიტის დონეზე. საწყობი შეიძლება იყოს ლიმიტზე მეტი, როდესაც აგებები მიმდინარეობს, ხოლო საწყობი, რომელიც უკვე მეტი იყო ლიმიტის დაყენებისას, მცირდება, როდესაც ახალი აგებები იმდენს ჩაწერენ. როდესაც რამდენიმე პროექტი იყენებს ერთსა და იმავე საწყობს, როგორც ეს ხდება მისი ნაგულისხმევი მდებარეობით, მოქმედებს მათი ლიმიტებიდან უმცირესი. ლიმიტი მოქმედებს ყოველ მანქანაზე, სადაც ასრულებთ `tuist setup cache`-ს, ამიტომ ლიმიტის შეცვლის შემდეგ კვლავ გაუშვით ის. ქეშის პროქსი, რომელიც უკვე მუშაობს, აგრძელებს მუშაობას და გამოიყენებს ახალ ლიმიტს შემდეგ შემოწმებისას.

### მოდულის ქეშის ჰეშები {#module-cache-hashes}

კომპილაციის ქეშის პარამეტრები არ შედის <.localized_link href="/guides/features/projects/hashing">მოდულის ქეშის ჰეშებში</.localized_link>. Tuist ტოვებს ყოველ `COMPILATION_CACHE_*` აგების პარამეტრს და ყოველ `-cas-plugin-option` დროშას მისი მნიშვნელობით ჰეშის გარეთ. `enableCaching`-ის ჩართვა ან გამორთვა, ან ატვირთვის პოლიტიკის შეცვლა, ინარჩუნებს თქვენი სამიზნეების ჰეშებს, ამიტომ <.localized_link href="/guides/features/cache/module-cache">მოდულის ქეშის</.localized_link> ბინარები, რომლებიც უკვე „გაათბეთ“, რჩებიან ვალიდურად. შეგიძლიათ შეადაროთ აგებები Xcode ქეშით და მის გარეშე ერთსა და იმავე მოდულის ქეშთან.

> [!NOTE]
> **პრეფიქსის ასახვის პარამეტრები ჰეშირდება**
>
> Xcode 27-სა და უფრო ახალ ვერსიებში, `enableCaching: true` ასევე აყენებს `SWIFT_ENABLE_PREFIX_MAPPING`, `SWIFT_ENABLE_PROJECT_PREFIX_MAPPING`, `CLANG_ENABLE_PREFIX_MAPPING`, `CLANG_ENABLE_PROJECT_PREFIX_MAPPING` და `TUIST_PREFIX_MAPPING_FOR_COVERAGE_*` პარამეტრებს. ეს პარამეტრები შედის მოდულის ქეშის ჰეშებში, ამიტომ Xcode 27-სა და უფრო ახალ ვერსიებში, `enableCaching`-ის ჩართვა ან გამორთვა ცვლის თქვენი სამიზნეების ჰეშებს.

### დიდი შედეგების ნაწილების ხელახალი გამოყენება {#reusing-parts-of-large-outputs}

როდესაც სერვერი მხარს უჭერს, Xcode ქეში გადასცემს დიდ შედეგებს ნაწილებად და გზავნის ან იწერს მხოლოდ იმ ნაწილებს, რომლებიც შეიცვალა წინა ვერსიასთან შედარებით. ნაწილები ინახება მცირე ლოკალურ ქეშში, `DerivedData`-ისგან ცალკე, ამიტომ ისინი რჩებიან კომპილაციის ქეშის გასუფთავების შემდეგაც. მცირე შედეგები, ძველი სერვერები და ძველი კლიენტები იყენებენ ჩვეულებრივ მთლიანი შედეგის გადაცემას.

ეს ამცირებს ჩამოტვირთული და ატვირთული მონაცემების რაოდენობას, არა გადაკომპილირებულის. „ცივ“ მანქანას, რომელსაც არ აქვს შესაბამისი ნაწილები, მაინც ჩამოაქვს მთლიანი შედეგი.

### უწყვეტი ინტეგრაცია {#continuous-integration}

CI გარემოში ქეშირების ჩასართავად, უნდა გაუშვათ იგივე ბრძანება, რაც ლოკალურ გარემოებში: `tuist setup cache`.

ავტორიზაციისთვის შეგიძლიათ გამოიყენოთ ან <.localized_link href="/guides/server/authentication#oidc-tokens">OIDC ავტორიზაცია</.localized_link> (რეკომენდებულია მხარდაჭერილი CI პროვაიდერებისთვის), ან <.localized_link href="/guides/server/authentication#account-tokens">ანგარიშის ტოკენი</.localized_link> `TUIST_TOKEN` გარემოს ცვლადის საშუალებით.

GitHub Actions-ის ნიმუში OIDC ავტორიზაციის გამოყენებით:
```yaml
name: Build

permissions:
  id-token: write
  contents: read

jobs:
  build:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v4
      - uses: jdx/mise-action@v2
      - run: tuist auth login
      - run: tuist setup cache
      - # Your build steps
```

მეტი მაგალითისთვის, მათ შორის ტოკენზე დაფუძნებული ავტორიზაციისა და სხვა CI პლატფორმების (Xcode Cloud, CircleCI, Bitrise და Codemagic) შესახებ, იხილეთ <.localized_link href="/guides/integrations/continuous-integration">უწყვეტი ინტეგრაციის სახელმძღვანელო</.localized_link>.

### კომპილაციის ქეშის საცავი CI-ზე {#compilation-cache-store-on-ci}

კომპილაციის ქეშის საცავი არის ლოკალური დირექტორია, სადაც Xcode ინახავს კომპილაციის შედეგებს. `COMPILATION_CACHE_CAS_PATH` ბილდის პარამეტრი განსაზღვრავს მის მდებარეობას, რომლის ნაგულისხმები მნიშვნელობაა `CompilationCache.noindex` `DerivedData`-ის შიგნით.

#### მდგომარეობის მქონე საცავი {#stateful-store}

ბილდებს შორის საცავის შესანარჩუნებლად, მიმართეთ `COMPILATION_CACHE_CAS_PATH` (და `TUIST_COMPILATION_CACHE_CAS_PATH` `tuist cache`-ისთვის) ერთ მუდმივ გზაზე და შეზღუდეთ მისი ზომა [საცავის ზომის ლიმიტით](#store-size-limit).

## პრობლემების გადაჭრა {#troubleshooting}

### ბილდები აფრთხილებენ, რომ Xcode ქეშის პროქსი ჩავარდა {#cas-proxy-failed}

თუ ბილდი აჩვენებს შემდეგნაირ გაფრთხილებას, რომელსაც Xcode უსწრებს `CAS error:` ან `CAS operation failed:` პრეფიქსს, იმის მიხედვით, თუ რომელი კომპილაცია წააწყდა შეცდომას პირველად:

```
warning: CAS error: The Tuist Xcode cache proxy at /Users/you/.local/state/tuist/cas-proxy.sock failed (proxy connect: No such file or directory (os error 2)). Compilations that needed it used the local cache only, without remote cache hits. Their uploads are kept on disk and sent once the proxy is reachable again. Run `tuist setup cache` if the proxy is not running.
```

მაშინ კომპილაციის ქეშმა ვერ მიაღწია ლოკალურ ქეშის პროქსის, რომელსაც `tuist setup cache` აყენებს. ბილდი მაინც წარმატებით სრულდება, მაგრამ შესაბამის კომპილაციებს არ აქვთ удаленные ქეშის მოხვედრები, ამიტომ ის მუშაობს როგორც ბილდი ცარიელი ქეშით. მათი ატვირთვები ინახება დისკზე და იგზავნება მაშინ, როცა პროქსი კვლავ დაამუშავებს მოთხოვნებს: იმავე ბილდის ფარგლებში, თუ ის დროულად აღდგება, ანდა სხვა შემთხვევაში შემდეგი ბილდის დროს იმავე მანქანაზე. CI მანქანა, რომელიც სამუშაოს შემდეგ იშლება, კარგავს მათ. გაფრთხილება ჩნდება ერთხელ ბილდზე, Xcode-ის Issue navigator-ში და `xcodebuild` გამოტანაში.

იმის შესამოწმებლად, მუშაობს თუ არა პროქსი, ეძებეთ პროცესი, რომელიც უსმენს გაფრთხილებაში მითითებულ სოკეტს:

```bash
lsof ~/.local/state/tuist/cas-proxy.sock
```

თუ ბრძანება არაფერს ბეჭდავს, გაუშვით `tuist setup cache` პროქსის ხელახლა ასამუშავებლად. CI-ზე, გაუშვით `tuist setup cache` ნებისმიერი `xcodebuild` გამოძახების წინ ყოველ სამუშაოში.

### ბილდები უკიდურესად ნელია და გამოსცემენ `CAS error: deadlineExceeded` გაფრთხილებებს {#cas-deadline-exceeded}

თუ თქვენი ბილდები მოსალოდნელზე ბევრად მეტ დროს იღებენ და Xcode-ის ბილდის ჟურნალი სავსეა შემდეგი გაფრთხილებებით:

```
Warning: CAS error: deadlineExceeded(connectionError: Optional(connect(descriptor:addr:size:): No such file or directory (errno: 2)))
note: cache key query failed
```

ან:

```
Warning: CAS error: deadlineExceeded(connectionError: Optional(connect(descriptor:addr:size:): Connection refused (errno: 61)))
```

მაშინ `COMPILATION_CACHE_REMOTE_SERVICE_PATH` მიუთითებს სოკეტზე, რომელსაც არაფერი უსმენს, ჩვეულებრივ ეს არის პროექტის სოკეტი (`~/.local/state/tuist/<org>_<project>.sock`), რომელსაც Tuist-ის ადრეული ვერსიები აყენებდნენ. Tuist აღარ ემსახურება ამ სოკეტს. Xcode ცდილობს კავშირის აღდგენას ყოველ კომპილაციის ქეშის მოთხოვნაზე სწრაფი შეცდომის ნაცვლად, რამაც შეიძლება ბილდი საათზე მეტხანს გააგრძელოს და Tuist ვერ ცვლის ამ ქცევას.

მის გამოსასწორებლად:

- **გენერირებული პროექტები**: ხელახლა გაუშვით `tuist generate`.
- **სხვა პროექტები**: ჩაანაცვლეთ `COMPILATION_CACHE_*` ბილდის პარამეტრები იმ პარამეტრებით, რომლებსაც `tuist setup cache` ბეჭდავს, როგორც აღწერილია [Xcode ბილდის პარამეტრების კონფიგურაციაში](#configure-xcode-build-settings).

თუ არ იყენებთ Xcode ქეშს, წაშალეთ `COMPILATION_CACHE_*` ბილდის პარამეტრები და გაუშვით `tuist teardown cache`.

### `uploaded CAS output` ჩნდება ლოკალურად მაშინაც, როცა ატვირთვები გამორთულია {#uploaded-cas-output-with-upload-disabled}

როდესაც დაყენებულია `xcodeCache: .xcodeCache(upload: false)` (ან `upload: Environment.isCI` არა-CI მანქანაზე), ბილდის ჟურნალში მაინც შეგიძლიათ ნახოთ `note: uploaded CAS output ...`. `xcodebuild`-ს არ აქვს ამ გამოძახებების გამოტოვების საშუალება, ამიტომ Tuist მაინც იღებს მათ, მაგრამ არაფერს აქვეყნებს Tuist სერვერზე. დაშბორდის მეტრიკები ითვალისწინებენ ამას, ამიტომ არ იგზავნება არასწორი ატვირთვის ტრაფიკი.

## დაკავშირებული {#related}

შეისწავლეთ [Tuist-ის საერთო ქეში](https://tuist.dev/cache), რათა ნახოთ, თუ როგორ იყენებენ ხელახლა ბილდის არტეფაქტებს საინჟინრო გუნდები და კოდირების აგენტები.
