Sets the used space of the worker in bytes.

@param tierAlias alias of storage tier
@param usedBytesOnTier used bytes on certain storage tier
434593
public void updateUsedBytes(String tierAlias, long usedBytesOnTier) {
    mUsedBytes += usedBytesOnTier - mUsedBytesOnTiers.get(tierAlias);
    mUsedBytesOnTiers.put(tierAlias, usedBytesOnTier);
  }
778860
public List<StorageTierView> getTierViewsBelow(String tierAlias) {
    int ordinal = getTierView(tierAlias).getTierViewOrdinal();
    return mTierViews.subList(ordinal + 1, mTierViews.size());
  }
871445
public Map<String, Integer> getOnTierPercentages() {
    return mOrderedTierAliases.stream().collect(Collectors.toMap(tier -> tier, tier -> {
      Long sizeOnTier = mSizeOnTier.getOrDefault(tier, 0L);
      return mSize > 0 ? (int) (100 * sizeOnTier / mSize) : 0;
    }));
  }
907252
public void addMemoryUsage(long memoryUsed) {
        totalMemoryUsage.increaseByLong(memoryUsed);
        minMemoryUsage.setValueIfLesserThanCurrentAsLong(memoryUsed);
        maxMemoryUsage.setValueIfGreaterThanCurrentAsLong(memoryUsed);
    }
137976
FreeSpace allocateSpace(long lengthRequired)
                    throws ObjectManagerException
    {
        final String methodName = "allocateSpace";
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        methodName,
                        new Object[] { new Long(lengthRequired) });

        // Find some free space, first search the free space map for the smallest
        // entry that will accommodate the request.
        FreeSpace freeSpace;

        java.util.SortedSet tailSet = freeSpaceByLength.tailSet(new FreeSpace(0, lengthRequired));
        if (!tailSet.isEmpty()) {
            // Use free space in the body of file.
            freeSpace = (FreeSpace) tailSet.first();
            tailSet.remove(freeSpace);

            long remainingLength = freeSpace.length - lengthRequired;

            if (remainingLength < minimumFreeSpaceEntrySize) {

                // All of this slot used up, also remove it from the address map.
                if (freeSpace.prev != null) {
                    freeSpace.prev.next = freeSpace.next;
                }
                else {
                    freeSpaceByAddressHead = freeSpace.next;
                }
                if (freeSpace.next != null) {
                    freeSpace.next.prev = freeSpace.prev;
                }
                // Return without any links
                freeSpace.prev = freeSpace.next = null;

                // Debug freespace list
                // if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled()) trace.debug(this, cclass, methodName, "REMOVE from freespace list");

            } else {
                // Partially used, reduce the length, but leave it in place in the address Map.
                // Allocate the end portion of the space found to a new FreeSpace area and  
                // add the remaining piece back into the length map, where its key will have changed. 
                freeSpace.length = remainingLength;
                freeSpaceByLength.add(freeSpace);

                freeSpace = new FreeSpace(freeSpace.address + remainingLength, lengthRequired);
            } // if (remainingLength == 0).

        } else {
            // Add to end of file.
            freeSpace = new FreeSpace(storeFileSizeUsed, lengthRequired);
            long newStoreFileSizeUsed = storeFileSizeUsed + lengthRequired;
            // Check to see if we need to extended the file. 
            if (newStoreFileSizeUsed > storeFileSizeAllocated) {
                storeFileExtendedDuringAllocation++;

                // This should not occur if we are using STRATEGY_KEEP_ALWAYS because we 
                // have already allocated enough space to store all the objects currently
                // in the log.
                if (storeStrategy == STRATEGY_KEEP_ALWAYS
                    && (objectManagerState.logFileType == ObjectManager.LOG_FILE_TYPE_FILE
                    || objectManagerState.logFileType == ObjectManager.LOG_FILE_TYPE_CLEAR)) {
                    ObjectManager.ffdc.processException(this,
                                                        cclass,
                                                        methodName,
                                                        new Exception("Extended allocated file"),
                                                        "1:1437:1.57",
                                                        new Object[] { new Long(newStoreFileSizeUsed), new Long(storeFileSizeAllocated) });
                    if (Tracing.isAnyTracingEnabled() && trace.isDebugEnabled())
                        trace.debug(this, cclass, methodName, new Object[] { "STRATEGY_KEEP_ALWAYS:1440",
                                                                            new Long(newStoreFileSizeUsed),
                                                                            new Long(storeFileSizeAllocated) });
                } // if ( objectManagerState.logFileType...

                if (newStoreFileSizeUsed <= maximumStoreFileSize
                    && setStoreFileSizeInternal(newStoreFileSizeUsed)) {

                } else {
                    allocationAllowed = false;

                    if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                        trace.exit(this,
                                   cclass,
                                   methodName,
                                   new Object[] { "ObjectStoreFull" });
                    throw new ObjectStoreFullException(this,
                                                       null);
                }
            } // if (newStoreFileSizeUsed > storeFileSizeAllocated).

            storeFileSizeUsed = newStoreFileSizeUsed;
        } // if (!tailMap.isEmpty()).

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       methodName,
                       new Object[] { freeSpace });
        return freeSpace;
    }
567353
public void setRemoveNetworkLoadBalancerArns(java.util.Collection<String> removeNetworkLoadBalancerArns) {
        if (removeNetworkLoadBalancerArns == null) {
            this.removeNetworkLoadBalancerArns = null;
            return;
        }

        this.removeNetworkLoadBalancerArns = new com.amazonaws.internal.SdkInternalList<String>(removeNetworkLoadBalancerArns);
    }
1126468
public void setStorageSize(java.util.Collection<Range> storageSize) {
        if (storageSize == null) {
            this.storageSize = null;
            return;
        }

        this.storageSize = new java.util.ArrayList<Range>(storageSize);
    }
1118943
@javax.annotation.Nonnull
  public com.simiacryptus.util.data.DensityTree setSplitSizeThreshold(int splitSizeThreshold) {
    this.splitSizeThreshold = splitSizeThreshold;
    return this;
  }
806238
public void makeSpace(int sizeNeeded) {
        int needed = count + sizeNeeded - buf.length;
        if (needed > 0) {
            bump(needed);
        }
    }
1341731
public void setRequestedBytes(int newRequestedBytes)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setRequestedBytes", newRequestedBytes);
      requestedBytes = newRequestedBytes;
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setRequestedBytes");
   }
761299
private void setNameSpaceID(File storage, String nsid)
      throws InconsistentFSStateException {
    if (nsid == null || nsid.equals("")) {
      throw new InconsistentFSStateException(storage, "file "
          + STORAGE_FILE_VERSION + " is invalid.");
    }
    int newNsId = Integer.parseInt(nsid);
    if (namespaceID > 0 && namespaceID != newNsId) {
      throw new InconsistentFSStateException(storage,
          "Unexepcted namespaceID " + nsid + " . Expected " + namespaceID);
    }
    namespaceID = newNsId;
  }
540675
public void addSpace(String spaceID, Map<String, AclType> userACLs, String storeID)
        throws ResourceException, InvalidIdException {
        IdUtil.validateSpaceId(spaceID);

        try {
            StorageProvider storage = storageProviderFactory.getStorageProvider(storeID);
            storage.createSpace(spaceID);

            waitForSpaceCreation(storage, spaceID);
            updateSpaceACLs(spaceID, userACLs, storeID);
        } catch (NotFoundException e) {
            throw new InvalidIdException(e.getMessage());
        } catch (Exception e) {
            storageProviderFactory.expireStorageProvider(storeID);
            throw new ResourceException("add space", spaceID, e);
        }
    }
1133005
private void calculateWorkspaceDataSize()
   {
      long dataSize;
      try
      {
         dataSize = getWorkspaceDataSizeDirectly();
      }
      catch (QuotaManagerException e1)
      {
         throw new IllegalStateException("Can't calculate workspace data size", e1);
      }

      ChangesItem changesItem = new ChangesItem();
      changesItem.updateWorkspaceChangedSize(dataSize);

      Runnable task = new ApplyPersistedChangesTask(context, changesItem);
      task.run();
   }
183948
public void setMaxStorageStrategy(int requestedMaxStrategy)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this,
                        tc,
                        "setMaxStorageStrategy",
                        Integer.valueOf(requestedMaxStrategy));
        maxStorageStrategy = requestedMaxStrategy;
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setMaxStorageStrategy");
    }
504712
public void setBytes(long memoryOffset, ByteBuffer buffer)
    {
        if (buffer == null)
            throw new NullPointerException();
        else if (buffer.remaining() == 0)
            return;

        int bufferOffset = buffer.position();

        checkPosition(memoryOffset);
        long end = memoryOffset + buffer.remaining();
        checkPosition(end - 1);
        while (memoryOffset < end)
        {
            unsafe.putByte(peer + memoryOffset, buffer.get(bufferOffset));
            memoryOffset++;
            bufferOffset++;
        }
    }
537453
func (s *DescribeWorkingStorageOutput) SetWorkingStorageUsedInBytes(v int64) *DescribeWorkingStorageOutput {
	s.WorkingStorageUsedInBytes = &v
	return s
}
1367988
public void setAliases(java.util.Collection<AliasListEntry> aliases) {
        if (aliases == null) {
            this.aliases = null;
            return;
        }

        this.aliases = new com.ibm.cloud.objectstorage.internal.SdkInternalList<AliasListEntry>(aliases);
    }