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()); }
protected void init() { // we want params validation here if (currentSize.get() > 0) { if (!isOver.get()) { if (workspaceConfiguration.getPolicyAllocation() == AllocationPolicy.OVERALLOCATE && workspaceConfiguration.getOverallocationLimit() > 0) { currentSize.addAndGet((long) (currentSize.get() * workspaceConfiguration.getOverallocationLimit())); isOver.set(true); } } if (workspaceConfiguration.getMaxSize() > 0 && currentSize.get() > workspaceConfiguration.getMaxSize()) currentSize.set(workspaceConfiguration.getMaxSize()); } }
private void initWorkspace() { workspace = Nd4j.getWorkspaceManager().createNewWorkspace( WorkspaceConfiguration.builder() .initialSize(memoryForGraph()) .policyAllocation(AllocationPolicy.OVERALLOCATE) .policyLearning(LearningPolicy.FIRST_LOOP) .build()); Nd4j.getWorkspaceManager().setWorkspaceForCurrentThread(workspace); }
size.incrementAndGet(); workspaceConfiguration = WorkspaceConfiguration.builder().cyclesBeforeInitialization(1) .policyAllocation(AllocationPolicy.STRICT).policyLearning(LearningPolicy.FIRST_LOOP) .policyMirroring(MirroringPolicy.FULL).policyReset(ResetPolicy.BLOCK_LEFT) .policySpill(SpillPolicy.REALLOCATE).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) {
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); } }
WorkspaceConfiguration initialConfig = WorkspaceConfiguration.builder() .initialSize(10 * 1024L * 1024L) .policyAllocation(AllocationPolicy.STRICT) .policyLearning(LearningPolicy.NONE) .build(); WorkspaceConfiguration learningConfig = WorkspaceConfiguration.builder() .policyAllocation(AllocationPolicy.STRICT) // <-- this option disables overallocation behavior .policyLearning(LearningPolicy.FIRST_LOOP) // <-- this option makes workspace learning after first loop .build(); WorkspaceConfiguration circularConfig = WorkspaceConfiguration.builder() .initialSize(10 * 1024L * 1024L) .policyAllocation(AllocationPolicy.STRICT) .policyLearning(LearningPolicy.NONE) // <-- this options disables workspace reallocation over time .policyReset(ResetPolicy.ENDOFBUFFER_REACHED) // <--- this option makes workspace act as circular buffer, beware. .build();
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()); }
@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);
protected void init() { // we want params validation here if (currentSize.get() > 0) { if (!isOver.get()) { if (workspaceConfiguration.getPolicyAllocation() == AllocationPolicy.OVERALLOCATE && workspaceConfiguration.getOverallocationLimit() > 0) { currentSize.addAndGet((long) (currentSize.get() * workspaceConfiguration.getOverallocationLimit())); isOver.set(true); } } if (workspaceConfiguration.getMaxSize() > 0 && currentSize.get() > workspaceConfiguration.getMaxSize()) currentSize.set(workspaceConfiguration.getMaxSize()); } }
@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; }
protected void initializeWorkspaces(long size) { WorkspaceConfiguration configuration = WorkspaceConfiguration.builder().initialSize(size) .overallocationLimit(bufferSize).policyReset(ResetPolicy.ENDOFBUFFER_REACHED) .policyAllocation(AllocationPolicy.OVERALLOCATE).policySpill(SpillPolicy.EXTERNAL) .policyLearning(LearningPolicy.NONE).build(); int numDevices = Nd4j.getAffinityManager().getNumberOfDevices(); int cDevice = Nd4j.getAffinityManager().getDeviceForCurrentThread(); for (int i = 0; i < numDevices; i++) { Nd4j.getAffinityManager().unsafeSetDevice(i); workspaces.add(Nd4j.getWorkspaceManager().createNewWorkspace(configuration, "IDSC-" + i, i)); } Nd4j.getAffinityManager().unsafeSetDevice(cDevice); numWorkspaces = numDevices; isInitialized = true; }
protected void initializeWorkspaces(long size) { WorkspaceConfiguration configuration = WorkspaceConfiguration.builder().initialSize(size) .overallocationLimit(bufferSize).policyReset(ResetPolicy.ENDOFBUFFER_REACHED) .policyAllocation(AllocationPolicy.OVERALLOCATE).policySpill(SpillPolicy.EXTERNAL) .policyLearning(LearningPolicy.NONE).build(); int numDevices = Nd4j.getAffinityManager().getNumberOfDevices(); int cDevice = Nd4j.getAffinityManager().getDeviceForCurrentThread(); for (int i = 0; i < numDevices; i++) { Nd4j.getAffinityManager().unsafeSetDevice(i); workspaces.add(Nd4j.getWorkspaceManager().createNewWorkspace(configuration, "IDSC-" + i, i)); } Nd4j.getAffinityManager().unsafeSetDevice(cDevice); numWorkspaces = numDevices; isInitialized = true; }
WorkspaceConfiguration configuration = WorkspaceConfiguration.builder().initialSize(initialMemory) .policyReset(ResetPolicy.ENDOFBUFFER_REACHED).policyAllocation(AllocationPolicy.STRICT) .policySpill(SpillPolicy.FAIL).policyLearning(LearningPolicy.NONE).build();