SP_DeviceMemoryBase* mem);

  // Deallocate the device memory previously allocated via this interface.
  // Deallocation of a nullptr-representative value is permitted.
  void (*deallocate)(const SP_Device* device, SP_DeviceMemoryBase* memory);

  // Allocates a region of host memory and registers it with the platform API.
  // Memory allocated in this manner is required for use in asynchronous memcpy

            return getAvailablePort()
        } finally {
            lock.unlock()
        }
    }

    /**
     * Deallocate the given port
     *
     * @param port
     */
    public void deallocate(int port) {
        try {
            lock.lock()
            allocated.removeAll(port)
        } finally {
            lock.unlock()
        }
    }

    private int getAvailablePort() {

type metricsRecorderInterface interface {
	setAllocated(allocated int)
	setAvailable(available int)
	incrementAllocations(scope string)
	incrementAllocationErrors(scope string)
}

// metricsRecorder implements metricsRecorderInterface.
type metricsRecorder struct{}

func (m *metricsRecorder) setAllocated(allocated int) {
	nodePortAllocated.Set(float64(allocated))
}

	if op.dryRun {
		if op.pa.Has(port) {
			return ErrAllocated
		}
		for _, a := range op.allocated {
			if port == a {
				return ErrAllocated
			}
		}
		op.allocated = append(op.allocated, port)
		return nil
	}

	err := op.pa.Allocate(port)
	if err == nil {
		op.allocated = append(op.allocated, port)
	}
	return err
}

  // +optional
  repeated ResourceClaimConsumerReference reservedFor = 3;

  // DeallocationRequested indicates that a ResourceClaim is to be
  // deallocated.
  //
  // The driver then must deallocate this claim and reset the field
  // together with clearing the Allocation field.
  //
  // While DeallocationRequested is set, no new consumers may be added to
  // ReservedFor.
  // +optional

					stored.Release(port)
				} else {
					// doesn't seem to be allocated
					nodePortRepairPortErrors.WithLabelValues("repair").Inc()
					c.recorder.Eventf(svc, nil, corev1.EventTypeWarning, "PortNotAllocated", "PortAllocation", "Port %d is not allocated; repairing", port)
					runtime.HandleError(fmt.Errorf("the node port %d for service %s/%s is not allocated; repairing", port, svc.Name, svc.Namespace))
				}

	if err != nil {
		t.Fatal(err)
	}
	r, err := NewInMemory(cidr)
	if err != nil {
		t.Fatal(err)
	}
	allocated := []net.IP{}
	for i := 0; i < 128; i++ {
		ip, err := r.AllocateNext()
		if err != nil {
			t.Fatal(err)
		}
		allocated = append(allocated, ip)
	}

	snapshot := api.RangeAllocation{}
	if err = r.Snapshot(&snapshot); err != nil {
		t.Fatal(err)
	}

			}
			if !okay {
				continue
			}
			// Found a matching, unallocated instance. Let's use it.
			//
			// A more thorough search would include backtracking because
			// allocating one "large" instances for a "small" request may
			// make a following "large" request impossible to satisfy when
			// only "small" instances are left.
			instances[i].Allocated = true
			indices = append(indices, i)
			break
		}
	}

		free:      2768 - 2,
		used:      2,
		allocated: 2,
		errors:    0,
	}
	expectMetrics(t, em)

	// try to allocate the same ports
	for s := range found {
		if !a.Has(s) {
			t.Fatalf("missing: %d", s)
		}
		if err := a.Allocate(s); err != ErrAllocated {
			t.Fatal(err)
		}
	}
	em = testMetrics{
		free:      2768 - 2,
		used:      2,
		allocated: 2,
		errors:    2,
	}

		// max out their size class, which are the ones we want.
		// We also allocate from small to large, so that the object which
		// maxes out its size class is the last one allocated in that class.
		// This allocation pattern leaves the next object in the class
		// unallocated, which we need to reproduce the bug.
		objs = append(objs, make([]*byte, i))
	}
	sink = objs // force heap allocation