public BasicWorkspaceManager() { this(WorkspaceConfiguration.builder().initialSize(0).maxSize(0).overallocationLimit(0.3) .policyAllocation(AllocationPolicy.OVERALLOCATE).policyLearning(LearningPolicy.FIRST_LOOP) .policyMirroring(MirroringPolicy.FULL).policySpill(SpillPolicy.EXTERNAL).build()); }
&& workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && (workspaceConfiguration.getMaxSize() == 0 || (maxCycle.get() < workspaceConfiguration.getMaxSize()))) { if (workspaceConfiguration.getPolicyReset() != ResetPolicy.ENDOFBUFFER_REACHED) { destroyWorkspace(true); isInit.set(false); if (workspaceConfiguration.getPolicyLearning() != LearningPolicy.NONE) { if (workspaceConfiguration.getMaxSize() > 0) currentSize.set(Math.min(maxCycle.get(), workspaceConfiguration.getMaxSize())); else currentSize.set(maxCycle.get()); if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED) { currentSize.set((long) (currentSize.get() * 1.3)); currentSize.addAndGet(8 - (currentSize.get() % 8)); if (workspaceConfiguration.getPolicyAllocation() == AllocationPolicy.OVERALLOCATE && workspaceConfiguration.getOverallocationLimit() > 0 && currentSize.get() > 0) { currentSize.set(currentSize.get() + (long) (currentSize.get() * workspaceConfiguration.getOverallocationLimit())); isOver.set(true); if (workspaceConfiguration.getMinSize() > 0 && currentSize.get() < workspaceConfiguration.getMinSize()) currentSize.set(workspaceConfiguration.getMinSize()); if (externalCount.get() > 0 && (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT || resetPlanned.get())) { clearExternalAllocations();
currentSize.set(workspaceConfiguration.getInitialSize()); if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED) workspaceType = Type.CIRCULAR; else workspaceType = Type.SCOPED; if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && workspaceConfiguration.getPolicyAllocation() == AllocationPolicy.OVERALLOCATE) { if (workspaceConfiguration.getOverallocationLimit() < 1.0) throw new ND4JIllegalStateException( "For cyclic workspace overallocation should be positive integral value."); stepsNumber = (int) (workspaceConfiguration.getOverallocationLimit() + 1); log.debug("Steps: {}", stepsNumber); if (configuration.getPolicyLocation() == LocationPolicy.MMAP) { if (configuration.getTempFilePath() != null) { tempFile = new File(configuration.getTempFilePath()); if (tempFile.length() == 0 || tempFile.length() < configuration.getInitialSize()) { if (configuration.getInitialSize() > 0) { try { fillFile(tempFile, configuration.getInitialSize()); } catch (Exception e) { throw new RuntimeException(e); configuration.setInitialSize(tempFile.length());
if (workspaceConfiguration.getPolicyLearning() != LearningPolicy.NONE && maxCycle.get() > 0) { if (externalCount.get() > 0 && (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT || resetPlanned.get())) { clearExternalAllocations(); if ((workspaceConfiguration.getPolicyLearning() == LearningPolicy.OVER_TIME && workspaceConfiguration.getCyclesBeforeInitialization() == cyclesCount.intValue()) || (workspaceConfiguration.getPolicyLearning() == LearningPolicy.FIRST_LOOP && currentSize.get() == 0)) { && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && workspaceConfiguration.getPolicyReset() != ResetPolicy.ENDOFBUFFER_REACHED) { if (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT) { reset(); } else if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && currentSize.get() > 0) {
requiredMemory += div; boolean trimmer = (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && requiredMemory + cycleAllocations.get() > initialBlockSize.get() && initialBlockSize.get() > 0 && kind == MemoryKind.DEVICE) || trimmedMode.get(); if (trimmer && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && !trimmedMode.get()) { trimmedMode.set(true); trimmedStep.set(stepsCount.get()); long prevOffset = deviceOffset.getAndAdd(requiredMemory); if (workspaceConfiguration.getPolicyMirroring() == MirroringPolicy.HOST_ONLY) return null; if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && currentSize.get() > 0 && !trimmer) { if (workspaceConfiguration.getPolicyMirroring() == MirroringPolicy.HOST_ONLY) return null; switch (workspaceConfiguration.getPolicySpill()) { case REALLOCATE: case EXTERNAL: switch (workspaceConfiguration.getPolicySpill()) { case REALLOCATE: case EXTERNAL:
boolean trimmer = (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && requiredMemory + cycleAllocations.get() > initialBlockSize.get() && initialBlockSize.get() > 0) || trimmedMode.get(); if (trimmer && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && !trimmedMode.get()) { trimmedMode.set(true); trimmedStep.set(stepsCount.get()); if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && currentSize.get() > 0 && !trimmer) { reset(); requiredMemory, numElements); switch (workspaceConfiguration.getPolicySpill()) { case REALLOCATE: case EXTERNAL:
public Nd4jWorkspace(@NonNull WorkspaceConfiguration configuration, @NonNull String workspaceId) { this.workspaceConfiguration = configuration; this.id = workspaceId; this.threadId = Thread.currentThread().getId(); this.guid = java.util.UUID.randomUUID().toString(); this.memoryManager = Nd4j.getMemoryManager(); this.deviceId = Nd4j.getAffinityManager().getDeviceForCurrentThread(); // and actual workspace allocation currentSize.set(workspaceConfiguration.getInitialSize()); if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && workspaceConfiguration.getPolicyAllocation() == AllocationPolicy.OVERALLOCATE) { if (workspaceConfiguration.getOverallocationLimit() < 1.0) throw new ND4JIllegalStateException("For cyclic workspace overallocation should be positive integral value."); stepsNumber = (int) (workspaceConfiguration.getOverallocationLimit() + 1); log.debug("Steps: {}", stepsNumber); } //if (workspaceConfiguration.getPolicyLearning() == LearningPolicy.OVER_TIME && workspaceConfiguration.getCyclesBeforeInitialization() < 1) //log.warn("Workspace [{}]: initialization OVER_TIME was selected, but number of cycles isn't positive value!", id); init(); }
@Override public MemoryWorkspace notifyScopeEntered() { // we should block stuff since we're going to invalidate spilled allocations // TODO: block on spilled allocations probably? MemoryWorkspace prev = Nd4j.getMemoryManager().getCurrentWorkspace(); // if we're opening the same workspace - just increase counter, and skip everything else if (prev == this && isOpen.get()) { tagScope.incrementAndGet(); return this; } // we'll need this in close() call, to restore previous workspace (if any) previousWorkspace = prev; Nd4j.getMemoryManager().setCurrentWorkspace(this); isOpen.set(true); // resetting workspace to 0 offset (if anything), not applicable to circular mode, sure if (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT) { reset(); } // if we have any spilled allocations left from last cycle - purge them. if (externalCount.get() > 0 && (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT || resetPlanned.get())) { clearExternalAllocations(); resetPlanned.set(false); } cycleAllocations.set(0); disabledCounter.set(0); generationId.incrementAndGet(); return this; }
@Override protected void init() { if (workspaceConfiguration.getPolicyLocation() == LocationPolicy.MMAP) { throw new ND4JIllegalStateException("CUDA do not support MMAP workspaces yet"); } super.init(); if (currentSize.get() > 0) { //log.info("Allocating {} bytes at DEVICE & HOST space...", currentSize.get()); isInit.set(true); long bytes = currentSize.get(); if (isDebug.get()) log.info("Allocating [{}] workspace on device_{}, {} bytes...", id, Nd4j.getAffinityManager().getDeviceForCurrentThread(), bytes); if (isDebug.get()) { Nd4j.getWorkspaceManager().printAllocationStatisticsForCurrentThread(); } Pointer ptr = memoryManager.allocate((bytes + SAFETY_OFFSET), MemoryKind.HOST, false); if (ptr == null) throw new ND4JIllegalStateException("Can't allocate memory for workspace"); workspace.setHostPointer(new PagedPointer(ptr)); if (workspaceConfiguration.getPolicyMirroring() != MirroringPolicy.HOST_ONLY) workspace.setDevicePointer(new PagedPointer(memoryManager.allocate((bytes + SAFETY_OFFSET), MemoryKind.DEVICE, false))); //log.info("Workspace [{}] initialized successfully", id); } }
@Override protected void init() { super.init(); if (currentSize.get() > 0) { //log.info("Allocating {} bytes at DEVICE & HOST space...", currentSize.get()); isInit.set(true); long bytes = currentSize.get(); if (isDebug.get()) log.info("Allocating [{}] workspace on device_{}, {} bytes...", id, Nd4j.getAffinityManager().getDeviceForCurrentThread(), bytes); if (isDebug.get()) { Nd4j.getWorkspaceManager().printAllocationStatisticsForCurrentThread(); } Pointer ptr = memoryManager.allocate((bytes + SAFETY_OFFSET), MemoryKind.HOST, false); if (ptr == null) throw new ND4JIllegalStateException("Can't allocate memory for workspace"); workspace.setHostPointer(new PagedPointer(ptr)); if (workspaceConfiguration.getPolicyMirroring() != MirroringPolicy.HOST_ONLY) workspace.setDevicePointer(new PagedPointer(memoryManager.allocate((bytes + SAFETY_OFFSET), MemoryKind.DEVICE, false))); //log.info("Workspace [{}] initialized successfully", id); } }
if (workspaceConfiguration.getPolicyLearning() != LearningPolicy.NONE && maxCycle.get() > 0) { if (externalCount.get() > 0 && (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT || resetPlanned.get())) { clearExternalAllocations(); resetPlanned.set(false); if ((workspaceConfiguration.getPolicyLearning() == LearningPolicy.OVER_TIME && workspaceConfiguration.getCyclesBeforeInitialization() == cyclesCount.intValue()) || (workspaceConfiguration.getPolicyLearning() == LearningPolicy.FIRST_LOOP && currentSize.get() == 0)) { } else if (currentSize.get() > 0 && cycleAllocations.get() > 0 && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && workspaceConfiguration.getPolicyReset() != ResetPolicy.ENDOFBUFFER_REACHED) { if (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT) { reset(); } else if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && currentSize.get() > 0) {
requiredMemory += div; boolean trimmer = (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && requiredMemory + cycleAllocations.get() > initialBlockSize.get() && initialBlockSize.get() > 0 && kind == MemoryKind.DEVICE) || trimmedMode.get(); if (trimmer && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && !trimmedMode.get()) { trimmedMode.set(true); trimmedStep.set(stepsCount.get()); long prevOffset = deviceOffset.getAndAdd(requiredMemory); if (workspaceConfiguration.getPolicyMirroring() == MirroringPolicy.HOST_ONLY) return null; if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && currentSize.get() > 0 && !trimmer && Nd4j.getWorkspaceManager().getDebugMode() != DebugMode.SPILL_EVERYTHING) { if (workspaceConfiguration.getPolicyMirroring() == MirroringPolicy.HOST_ONLY) return null; switch (workspaceConfiguration.getPolicySpill()) { case REALLOCATE: case EXTERNAL: switch (workspaceConfiguration.getPolicySpill()) { case REALLOCATE: case EXTERNAL:
boolean trimmer = (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && requiredMemory + cycleAllocations.get() > initialBlockSize.get() && initialBlockSize.get() > 0) || trimmedMode.get(); if (trimmer && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && !trimmedMode.get()) { trimmedMode.set(true); trimmedStep.set(stepsCount.get()); if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED && currentSize.get() > 0 && !trimmer) { reset(); resetPlanned.set(true); log.info("Workspace [{}]: step: {}, spilled {} bytes, capacity of {} elements", id, stepsCount.get(), requiredMemory, numElements); switch (workspaceConfiguration.getPolicySpill()) { case REALLOCATE: case EXTERNAL:
@Override public MemoryWorkspace notifyScopeEntered() { // we should block stuff since we're going to invalidate spilled allocations // TODO: block on spilled allocations probably? MemoryWorkspace prev = Nd4j.getMemoryManager().getCurrentWorkspace(); // if we're opening the same workspace - just increase counter, and skip everything else if (prev == this && isOpen.get()) { tagScope.incrementAndGet(); return this; } // we'll need this in close() call, to restore previous workspace (if any) previousWorkspace = prev; Nd4j.getMemoryManager().setCurrentWorkspace(this); isOpen.set(true); // resetting workspace to 0 offset (if anything), not applicable to circular mode, sure if (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT) { reset(); } // if we have any spilled allocations left from last cycle - purge them. if (externalCount.get() > 0 && (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT || resetPlanned.get())) { clearExternalAllocations(); resetPlanned.set(false); } cycleAllocations.set(0); disabledCounter.set(0); return this; }
@Override public void initializeWorkspace() { if ((currentSize.get() < maxCycle.get() || currentSize.get() < cycleAllocations.get()) && workspaceConfiguration.getPolicySpill() == SpillPolicy.REALLOCATE && (workspaceConfiguration.getMaxSize() == 0 || (maxCycle.get() < workspaceConfiguration.getMaxSize()))) { if (workspaceConfiguration.getPolicyReset() != ResetPolicy.ENDOFBUFFER_REACHED) { destroyWorkspace(true); isInit.set(false); if (workspaceConfiguration.getPolicyLearning() != LearningPolicy.NONE) { if (workspaceConfiguration.getMaxSize() > 0) currentSize.set(Math.min(maxCycle.get(), workspaceConfiguration.getMaxSize())); else currentSize.set(maxCycle.get()); if (workspaceConfiguration.getPolicyReset() == ResetPolicy.ENDOFBUFFER_REACHED) { currentSize.set((long) (currentSize.get() * 1.3)); currentSize.addAndGet(8 - (currentSize.get() % 8)); if (workspaceConfiguration.getPolicyAllocation() == AllocationPolicy.OVERALLOCATE && workspaceConfiguration.getOverallocationLimit() > 0 && currentSize.get() > 0) { currentSize.set(currentSize.get() + (long) (currentSize.get() * workspaceConfiguration.getOverallocationLimit())); isOver.set(true); if (workspaceConfiguration.getMinSize() > 0 && currentSize.get() < workspaceConfiguration.getMinSize()) currentSize.set(workspaceConfiguration.getMinSize()); if (externalCount.get() > 0 && (workspaceConfiguration.getPolicyReset() == ResetPolicy.BLOCK_LEFT || resetPlanned.get())) { clearExternalAllocations(); resetPlanned.set(false);
private void initWorkspace() { workspace = Nd4j.getWorkspaceManager().createNewWorkspace( WorkspaceConfiguration.builder() .initialSize(memoryForGraph()) .policyAllocation(AllocationPolicy.OVERALLOCATE) .policyLearning(LearningPolicy.FIRST_LOOP) .build()); Nd4j.getWorkspaceManager().setWorkspaceForCurrentThread(workspace); }
WorkspaceConfiguration initialConfig = WorkspaceConfiguration.builder() .initialSize(10 * 1024L * 1024L) .policyAllocation(AllocationPolicy.STRICT) WorkspaceConfiguration learningConfig = WorkspaceConfiguration.builder() WorkspaceConfiguration circularConfig = WorkspaceConfiguration.builder() .initialSize(10 * 1024L * 1024L) .policyAllocation(AllocationPolicy.STRICT)
public BasicWorkspaceManager() { this(WorkspaceConfiguration.builder().initialSize(0).maxSize(0).overallocationLimit(0.3).policyAllocation(AllocationPolicy.OVERALLOCATE).policyLearning(LearningPolicy.FIRST_LOOP).policyMirroring(MirroringPolicy.FULL).policySpill(SpillPolicy.EXTERNAL).build()); }
size.incrementAndGet(); workspaceConfiguration = WorkspaceConfiguration.builder().cyclesBeforeInitialization(1) .policyAllocation(AllocationPolicy.STRICT).policyLearning(LearningPolicy.FIRST_LOOP) .policyMirroring(MirroringPolicy.FULL).policyReset(ResetPolicy.BLOCK_LEFT)
WorkspaceConfiguration configuration = WorkspaceConfiguration.builder().initialSize(initialMemory) .policyReset(ResetPolicy.ENDOFBUFFER_REACHED).policyAllocation(AllocationPolicy.STRICT) .policySpill(SpillPolicy.FAIL).policyLearning(LearningPolicy.NONE).build();