* Such work can reuse outputs from a previous execution.
 */
public interface MutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link MutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */
    MutableWorkspaceProvider getWorkspaceProvider();

 */
public interface ImmutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link ImmutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */
    ImmutableWorkspaceProvider getWorkspaceProvider();

// to manage containers. For example, they contain functions to configure containers' cgroups,
// ensure containers run with the desired QoS, and allocate compute resources like cpus, memory,
// devices...

// Malloc small size classes.
//
// See malloc.go for overview.
// See also mksizeclasses.go for how we decide what size classes to use.

package runtime

// Returns size of the memory block that mallocgc will allocate if you ask for the size,
// minus any inline space for metadata.
func roundupsize(size uintptr, noscan bool) (reqSize uintptr) {
	reqSize = size
	if reqSize <= maxSmallSize-mallocHeaderSize {
		// Small object.

        result.toString() == new String(iso8859bytes, "ISO-8859-1")
        result.toString() != new String(iso8859bytes, "UTF-8")
    }

    static ByteBuffer buffer(byte[] bytes) {
        ByteBuffer byteBuffer = ByteBuffer.allocate(bytes.length)
        byteBuffer.put(bytes)
        byteBuffer.rewind()
        return byteBuffer
    }

     * full contract of {@link java.net.URL} clients of this interface.
     * Specifically, {@link java.net.URL} extends {@link URI} to add network
     * operations which are both unsuited for simple data specification and
     * allocate additional memory.</p>
     */
    URI getUrl();

    /**
     * Sets the URL of the repository.
     */
    void setUrl(URI url);

    /**
     * Sets the URL of the repository.
     */

import (
	"runtime"
	"time"
	"unsafe"
)

func main() {
	runtime.MemProfileRate = 1
	// Allocate 1M 4-byte objects and set a finalizer for every third object.
	// Assuming that tiny block size is 16, some objects get finalizers setup
	// only for middle bytes. The finalizer resurrects that object.
	// As the result, all allocated memory must stay alive.
	const (
		N             = 1 << 20
		tinyBlockSize = 16 // runtime._TinySize
	)

			return false, fmt.Errorf("checking node %q and resources of driver %q: %w", nodeName, driverName, err)
		}
		if !okay {
			return false, nil
		}
	}
	return true, nil
}

func (c claimController) allocate(ctx context.Context, nodeName string, resources resources) (string, *resourcev1alpha2.AllocationResult, error) {
	allocation := &resourcev1alpha2.AllocationResult{
		Shareable: c.claimParameters.Shareable,

	blockSize = 1024
)

// ReadAtMost reads at most max bytes from the end of the file identified by path or
// returns an error. It returns true if the file was longer than max. It will
// allocate up to max bytes.
func ReadAtMost(path string, max int64) ([]byte, bool, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, false, err
	}
	defer f.Close()
	fi, err := f.Stat()
	if err != nil {

	// concrete resource allocations per Pod in terms of NUMA locality hints.
	GetPodTopologyHints(pod *v1.Pod) map[string][]TopologyHint
	// Allocate triggers resource allocation to occur on the HintProvider after
	// all hints have been gathered and the aggregated Hint is available via a
	// call to Store.GetAffinity().
	Allocate(pod *v1.Pod, container *v1.Container) error
}

// Store interface is to allow Hint Providers to retrieve pod affinity