Merge branch 'main' into mcu_trunk

Author: psiddh

.github/workflows/stale.yml

@@ -0,0 +1,149 @@
+# The behavior is:
+# - If a PR is not labeled stale, after 60 days inactivity label the PR as stale and comment about it.
+# - If a PR is labeled stale, after 30 days inactivity close the PR.
+# - `high priority` and `no-stale` PRs are exempt.
+
+name: Close stale pull requests
+
+on:
+  schedule:
+    # Run daily at 00:30 UTC.
+    - cron: '30 0 * * *'
+  workflow_dispatch:
+
+jobs:
+  stale:
+    if: ${{ github.repository == 'pytorch/executorch' }}
+    runs-on: linux.large
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            // Do some dumb retries on requests.
+            const retries = 7;
+            const baseBackoff = 100;
+            const sleep = timeout => new Promise(resolve => setTimeout(resolve, timeout));
+            github.hook.wrap('request', async (request, options) => {
+              for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                  return await request(options);
+                } catch (err) {
+                  if (attempt < retries) {
+                    core.warning(`Request getting retried. Attempt: ${attempt}`);
+                    await sleep(baseBackoff * Math.pow(2, attempt));
+                    continue;
+                  }
+                  throw err;
+                }
+              }
+            });
+
+            const MAX_API_REQUESTS = 100;
+
+            // If a PRs not labeled stale, label them stale after no update for 60 days.
+            const STALE_LABEL_THRESHOLD_MS = 1000 * 60 * 60 * 24 * 60;
+            // For PRs already labeled stale, close after not update for 30 days.
+            const STALE_CLOSE_THRESHOLD_MS = 1000 * 60 * 60 * 24 * 30;
+
+            const STALE_MESSAGE =
+              "Looks like this PR hasn't been updated in a while so we're going to go ahead and mark this as `Stale`. <br>" +
+              "Feel free to remove the `Stale` label if you feel this was a mistake. <br>" +
+              "If you are unable to remove the `Stale` label please contact a maintainer in order to do so. <br>" +
+              "If you want the bot to never mark this PR stale again, add the `no-stale` label.<br>" +
+              "`Stale` pull requests will automatically be closed after 30 days of inactivity.<br>";
+
+            let numAPIRequests = 0;
+            let numProcessed = 0;
+
+            async function processPull(pull) {
+              core.info(`[${pull.number}] URL: ${pull.html_url}`);
+              numProcessed += 1;
+              const labels = pull.labels.map((label) => label.name);
+
+              // Skip if certain labels are present.
+              if (labels.includes("no-stale") || labels.includes("high priority")) {
+                core.info(`[${pull.number}] Skipping because PR has an exempting label.`);
+                return false;
+              }
+
+              // Check if the PR is stale, according to our configured thresholds.
+              let staleThresholdMillis;
+              if (labels.includes("Stale")) {
+                core.info(`[${pull.number}] PR is labeled stale, checking whether we should close it.`);
+                staleThresholdMillis = STALE_CLOSE_THRESHOLD_MS;
+              } else {
+                core.info(`[${pull.number}] Checking whether to label PR as stale.`);
+                staleThresholdMillis = STALE_LABEL_THRESHOLD_MS;
+              }
+
+              const millisSinceLastUpdated =
+                new Date().getTime() - new Date(pull.updated_at).getTime();
+
+              if (millisSinceLastUpdated < staleThresholdMillis) {
+                core.info(`[${pull.number}] Skipping because PR was updated recently`);
+                return false;
+              }
+
+              // At this point, we know we should do something.
+              // For PRs already labeled stale, close them.
+              if (labels.includes("Stale")) {
+                core.info(`[${pull.number}] Closing PR.`);
+                numAPIRequests += 1;
+                  //await github.rest.issues.update({
+                  //owner: "pytorch",
+                  //repo: "executorch",
+                  //issue_number: pull.number,
+                  //state: "closed",
+                  //});
+              } else {
+                // For PRs not labeled stale, label them stale.
+                core.info(`[${pull.number}] Labeling PR as stale.`);
+
+                numAPIRequests += 1;
+                  //await github.rest.issues.createComment({
+                  //owner: "pytorch",
+                  //repo: "executorch",
+                  //issue_number: pull.number,
+                  //body: STALE_MESSAGE,
+                //});
+
+                numAPIRequests += 1;
+                  //await github.rest.issues.addLabels({
+                  //owner: "pytorch",
+                  //repo: "executorch",
+                  //issue_number: pull.number,
+                  //labels: ["Stale"],
+                //});
+              }
+            }
+
+            for await (const response of github.paginate.iterator(
+              github.rest.pulls.list,
+              {
+                owner: "pytorch",
+                repo: "executorch",
+                state: "open",
+                sort: "created",
+                direction: "asc",
+                per_page: 100,
+              }
+            )) {
+              numAPIRequests += 1;
+              const pulls = response.data;
+              // Awaiting in a loop is intentional here. We want to serialize execution so
+              // that log groups are printed correctl
+              for (const pull of pulls) {
+                if (numAPIRequests > MAX_API_REQUESTS) {
+                  core.warning("Max API requests exceeded, exiting.");
+                  process.exit(0);
+                }
+                await core.group(`Processing PR #${pull.number}`, async () => {
+                  await processPull(pull);
+                });
+              }
+            }
+            core.info(`Processed ${numProcessed} PRs total.`);

backends/apple/coreml/runtime/delegate/ETCoreMLAssetManager.h

@@ -99,6 +99,17 @@ NS_ASSUME_NONNULL_BEGIN
 - (NSUInteger)compact:(NSUInteger)sizeInBytes error:(NSError* __autoreleasing*)error;
 
 
+/// Executes a block with a unique temporary directory.
+///
+/// A new temporary subdirectory URL is created inside the receiver’s designated
+/// base directory. The directory is passed to the block, which can use it to
+/// perform temporary file operations. After the block finishes executing,
+/// the directory and its contents are removed.
+///
+/// @param block A block to execute. The block receives a unique URL.
+- (void)withTemporaryDirectory:(void (^)(NSURL* directoryURL))block;
+
+
 /// Purges the assets storage. The assets are moved to the trash directory and are asynchronously
 /// deleted.
 ///
@@ -117,6 +128,12 @@ NS_ASSUME_NONNULL_BEGIN
 /// contents are deleted asynchronously.
 @property (copy, readonly, nonatomic) NSURL* trashDirectoryURL;
 
+
+/// The staging directory URL, used to hold assets that are being prepared or processed
+/// before they are moved into their final location. The contents of this directory
+/// are temporary and may be cleared when no longer needed.
+@property (copy, readonly, nonatomic) NSURL* stagingDirectoryURL;
+
 /// The file manager.
 @property (strong, readonly, nonatomic) NSFileManager* fileManager;
 

backends/apple/coreml/runtime/delegate/ETCoreMLAssetManager.mm

@@ -254,6 +254,29 @@ BOOL is_asset_alive(NSMapTable<NSString *, ETCoreMLAsset *> *assets_in_use_map,
 
     return assets;
 }
+
+NSURL * _Nullable move_to_directory(NSURL *url,
+                                    NSURL *directoryURL,
+                                    NSFileManager *fileManager,
+                                    NSError * __autoreleasing *error) {
+    if (!url) {
+        ETCoreMLLogErrorAndSetNSError(error, ETCoreMLErrorInternalError, "Move operation failed: source URL is nil.");
+        return nil;
+    }
+
+    if (!directoryURL) {
+        ETCoreMLLogErrorAndSetNSError(error, ETCoreMLErrorInternalError, "Move operation failed: destination URL is nil.");
+        return nil;
+    }
+
+    NSURL *dstURL = [directoryURL URLByAppendingPathComponent:[NSUUID UUID].UUIDString];
+    if (![fileManager moveItemAtURL:url toURL:dstURL error:error]) {
+        return nil;
+    }
+
+    return dstURL;
+}
+
 } //namespace
 
 @interface ETCoreMLAssetManager () <NSFileManagerDelegate> {
@@ -299,12 +322,17 @@ - (nullable instancetype)initWithDatabase:(const std::shared_ptr<Database>&)data
     if (!managedAssetsDirectoryURL) {
         return nil;
     }
-    
+
     NSURL *managedTrashDirectoryURL = ::create_directory_if_needed(trashDirectoryURL, @"models", fileManager, error);
     if (!managedTrashDirectoryURL) {
         return nil;
     }
-    
+
+    NSURL *managedStagingDirectoryURL = ::create_directory_if_needed(assetsDirectoryURL, @"staging", fileManager, error);
+    if (!managedStagingDirectoryURL) {
+        return nil;
+    }
+
     // If directory is empty then purge the stores
     if (::is_directory_empty(managedAssetsDirectoryURL, fileManager, nil)) {
         assetsMetaStore.impl()->purge(ec);
@@ -315,6 +343,7 @@ - (nullable instancetype)initWithDatabase:(const std::shared_ptr<Database>&)data
         _assetsStore = std::move(assetsStore);
         _assetsMetaStore = std::move(assetsMetaStore);
         _assetsDirectoryURL = managedAssetsDirectoryURL;
+        _stagingDirectoryURL = managedStagingDirectoryURL;
         _trashDirectoryURL = managedTrashDirectoryURL;
         _estimatedSizeInBytes = sizeInBytes.value();
         _maxAssetsSizeInBytes = maxAssetsSizeInBytes;
@@ -346,15 +375,15 @@ - (nullable instancetype)initWithDatabaseURL:(NSURL *)databaseURL
                             error:error];
 }
 
-- (nullable NSURL *)moveURL:(NSURL *)url
-     toUniqueURLInDirectory:(NSURL *)directoryURL
-                      error:(NSError * __autoreleasing *)error {
-    NSURL *dstURL = [directoryURL URLByAppendingPathComponent:[NSUUID UUID].UUIDString];
-    if (![self.fileManager moveItemAtURL:url toURL:dstURL error:error]) {
-        return nil;
+- (void)withTemporaryDirectory:(void (^)(NSURL *directoryURL))block {
+    NSURL *dstURL = [self.stagingDirectoryURL URLByAppendingPathComponent:[NSUUID UUID].UUIDString];
+    block(dstURL);
+    if (![self.fileManager fileExistsAtPath:dstURL.path]) {
+        return;
     }
-    
-    return dstURL;
+
+    move_to_directory(dstURL, self.trashDirectoryURL, self.fileManager, nil);
+    [self cleanupTrashDirectory];
 }
 
 - (void)cleanupAssetIfNeeded:(ETCoreMLAsset *)asset {
@@ -407,9 +436,8 @@ - (nullable ETCoreMLAsset *)_storeAssetAtURL:(NSURL *)srcURL
             return false;
         }
 
-        // If an asset exists move it
-        [self moveURL:dstURL toUniqueURLInDirectory:self.trashDirectoryURL error:nil];
-        
+        // If a file already exists at `dstURL`, move it to the trash for removal.
+        move_to_directory(dstURL, self.trashDirectoryURL, self.fileManager, nil);
         // Move the asset to assets directory.
         if (![self.fileManager moveItemAtURL:srcURL toURL:dstURL error:error]) {
             return false;
@@ -433,16 +461,25 @@ - (nullable ETCoreMLAsset *)_storeAssetAtURL:(NSURL *)srcURL
 }
 
 - (void)triggerCompaction {
-    if (self.estimatedSizeInBytes < self.maxAssetsSizeInBytes) {
-        return;
+    if (self.estimatedSizeInBytes >= self.maxAssetsSizeInBytes) {
+        __weak __typeof(self) weakSelf = self;
+        dispatch_async(self.syncQueue, ^{
+            NSError *localError = nil;
+            if (![weakSelf _compact:self.maxAssetsSizeInBytes error:&localError]) {
+                ETCoreMLLogError(localError, "Failed to compact asset store.");
+            }
+        });
     }
-    
+
+    // Always clean the trash directory to ensure a minimal footprint.
+    // The `trashQueue` is serialized, so only one cleanup will run at a time.
+    [self cleanupTrashDirectory];
+}
+
+- (void)cleanupTrashDirectory {
     __weak __typeof(self) weakSelf = self;
-    dispatch_async(self.syncQueue, ^{
-        NSError *localError = nil;
-        if (![weakSelf _compact:self.maxAssetsSizeInBytes error:&localError]) {
-            ETCoreMLLogError(localError, "Failed to compact asset store.");
-        }
+    dispatch_async(self.trashQueue, ^{
+        [weakSelf removeFilesInTrashDirectory];
     });
 }
 
@@ -548,7 +585,7 @@ - (BOOL)_removeAssetWithIdentifier:(NSString *)identifier
 
         NSURL *assetURL = ::get_asset_url(assetValue);
         if ([self.fileManager fileExistsAtPath:assetURL.path] &&
-            ![self moveURL:assetURL toUniqueURLInDirectory:self.trashDirectoryURL error:error]) {
+            !move_to_directory(assetURL, self.trashDirectoryURL, self.fileManager, error)) {
             return false;
         }
 
@@ -649,13 +686,7 @@ - (NSUInteger)_compact:(NSUInteger)sizeInBytes error:(NSError * __autoreleasing
                              identifier);
         }
     }
-    
-    // Trigger cleanup.
-    __weak __typeof(self) weakSelf = self;
-    dispatch_async(self.trashQueue, ^{
-        [weakSelf removeFilesInTrashDirectory];
-    });
-    
+
     return _estimatedSizeInBytes;
 }
 
@@ -664,7 +695,10 @@ - (NSUInteger)compact:(NSUInteger)sizeInBytes error:(NSError * __autoreleasing *
     dispatch_sync(self.syncQueue, ^{
         result = [self _compact:sizeInBytes error:error];
     });
-    
+
+    // Always clean the trash directory to ensure a minimal footprint.
+    // The `trashQueue` is serialized, so only one cleanup will run at a time.
+    [self cleanupTrashDirectory];
     return result;
 }
 
@@ -708,7 +742,7 @@ - (BOOL)_purge:(NSError * __autoreleasing *)error {
         }
 
         // Move the the whole assets directory to the temp directory.
-        if (![self moveURL:self.assetsDirectoryURL toUniqueURLInDirectory:self.trashDirectoryURL error:error]) {
+        if (!move_to_directory(self.assetsDirectoryURL, self.trashDirectoryURL, self.fileManager, error)) {
             return false;
         }
 
@@ -724,13 +758,7 @@ - (BOOL)_purge:(NSError * __autoreleasing *)error {
 
     ::set_error_from_error_code(ec, error);
     // Trigger cleanup
-    if (status) {
-        __weak __typeof(self) weakSelf = self;
-        dispatch_async(self.trashQueue, ^{
-            [weakSelf removeFilesInTrashDirectory];
-        });
-    }
-    
+    [self cleanupTrashDirectory];
     return static_cast<BOOL>(status);
 }
 

backends/apple/coreml/runtime/delegate/ETCoreMLModelLoader.mm

@@ -62,21 +62,12 @@ + (nullable ETCoreMLModel *)loadModelWithContentsOfURL:(NSURL *)compiledModelURL
     if (model) {
         return model;
     }
-    
-    if (localError) {
-        ETCoreMLLogError(localError,
-                         "Failed to load model from compiled asset with identifier = %@",
-                         identifier);
-    }
-    
-    // If store failed then we will load the model from compiledURL.
-    auto backingAsset = Asset::make(compiledModelURL, identifier, assetManager.fileManager, error);
-    if (!backingAsset) {
-        return nil;
+
+    if (error) {
+        *error = localError;
     }
-    
-    asset = [[ETCoreMLAsset alloc] initWithBackingAsset:backingAsset.value()];
-    return ::get_model_from_asset(asset, configuration, metadata, error);
+
+    return nil;
 }
 
 @end