python.multiprocessing e "FATAL ERROR (INFADI) MISSING DIRECTORY"

Durante il tentativo di eseguire il multiprocessing con arcpy, di tanto in tanto mi imbatto in questo errore:

FATAL ERROR (INFADI)
MISSING DIRECTORY

Non ho idea di cosa stia scatenando questo errore e si blocca il processo Python, rendendo impossibile ottenere un traceback su di esso. Si verifica durante la scrittura dell'uscita raster finale da un lungo modello audio.

A volte è accompagnato da un errore

Unable to write BND file for %TEMP%\ras####

Dove% Temp è analizzato correttamente e #### è un numero casuale di 4 cifre. Questo è insolito perché ogni processo ha il suo spazio di lavoro, che è dove la maggior parte dei file dovrebbe essere scritta.

Il problema non sono i dati di input ... Posso rieseguire il programma sugli input non riusciti e funzionerà correttamente.

Ecco alcune cose da controllare:

Stai usando i cursori? Li stai rilasciando? Stai cercando di riutilizzare qualsiasi oggetto in diversi processi? Stai condividendo la stessa posizione temporanea? Stai eseguendo l'elaborazione della memoria?

In generale, arcpy è solo un involucro attorno agli oggetti com e qualsiasi tipo di multiprocessing sarà complicato.

Ho riscontrato che questo problema si presenta quando arcpy.env.workspace e arcpy.env.scratchWorkspace sono uguali per due processi diversi. Arc scrive quasi tutti i raster intermedi nell'area di lavoro (o area di lavoro scratch) nel formato ESRI GRID. Non è possibile scrivere due raster ESRI GRID contemporaneamente nella stessa directory a causa della struttura pseudo-database del formato (la cartella delle informazioni contiene chiavi univoche per ciascun raster).

Ho evitato questo errore assegnando spazio di lavoro unico e scratchWorkspace per ogni processo usando una cartella temporanea tempfile.mkdtemp.

Ho riscontrato anche questo e non ho ancora trovato una soluzione audio. Il mio lavoro è 1) per assicurarmi che l'attività di elaborazione multipla sia abbastanza solida da verificare se le attività sono complete o meno, quindi creare un nuovo elenco di lavori. 2) programmare due script da avviare ogni 10-15 minuti. Uno script contiene un comando per eliminare determinati processi Python in esecuzione e il secondo riavvia lo script multiprocessing desiderato. In sostanza, questo aggiorna il pool di elaborazione multipla. Il kill script è qualcosa del genere:

def read_pid():
    inFile = open("E:/temp/pid.csv")
    for line in inFile:
        pid = str(line)
    inFile.close()
    return pid

def kill():
    if os.path.exists("E:/temp/pid.csv")==True:
        pid = read_pid()
        PROCESS_TERMINATE=1
        handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE,False,pid)
        ctypes.windll.kernel32.TerminateProcess(handle,-1)
        ctypes.windll.kernel32.CloseHandle(handle)
    else:
        return

Ogni lancio dello script desiderato lo fa scrivere il suo PID su un CSV.

Devo ammettere che sono a questo punto, solo un aspirante multithreading, ma un blog su https://pythongisandstuff.wordpress.com/2013/07/31/using-arcpy-with-multiprocessing-%E2%80%93-part -3 / suggerisce che l'integrazione della arcpy.Exists()funzione è la chiave per realizzarla.

Ho scoperto che stavo ricevendo l'errore INFADI durante il tentativo di salvare e modificare più raster in una cartella più thread / core. L'assegnazione di una sottocartella a ciascuna attività per gli output sembra risolvere il problema. Credo che il problema riguardasse più letture / scritture su file periferici associati al raster (ad esempio la cartella "info"). Ora uso anche le seguenti precauzioni:

import arcpy,multiprocessing,random

def run(foo,c):
    tempFolder = os.path.join("Z:/temp/",'temp_%s'%(str(c)))
    if not os.path.exists(tempFolder): os.mkdir(tempFolder)
    arcpy.env.scratchWorkspace = tempFolder
    arcpy.env.Workspace = tempFolder

    # create unique object in memory, run task, then delete unique object in memory
    tempMem = str(rnd)
    try:arcpy.Delete_management(tempMem)
    except:pass

    <tasks> #output to appropriate subfolder

    arcpy.Delete_management(tempMem)

if __name__ == '__main__':
    cores = 3
    pool = multiprocessing.Pool(cores)
    count = 0
    for foo in bar:
        pool.apply_async(run,(foo,c))
        count +=1
    pool.close()
    pool.join()