package org.gradle.process.internal.health.memory;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface MemoryManager {

    void addListener(JvmMemoryStatusListener listener);

    void addListener(OsMemoryStatusListener listener);

    void removeListener(JvmMemoryStatusListener listener);

        osMemoryInfo.freeMemory = MemoryAmount.of('4g').bytes
        def memoryManager = newMemoryManager()

        and:
        def holder = Mock(MemoryHolder)
        memoryManager.addMemoryHolder(holder)

        when:
        memoryManager.requestFreeMemory(0)

        then:
        0 * holder.attemptToRelease(_)

        cleanup:
        memoryManager.stop()
    }

            import org.gradle.process.internal.health.memory.MemoryManager

            task expireWorkers {
                doFirst {
                    def freeMemory
                    CountDownLatch latch = new CountDownLatch(1)
                    def memoryManager = services.get(MemoryManager.class)
                    memoryManager.addListener(new OsMemoryStatusListener() {

    private final OutputEventListener outputEventListener;
    private final ApplicationClassesInSystemClassLoaderWorkerImplementationFactory workerImplementationFactory;
    private final MemoryManager memoryManager;
    private int connectTimeoutSeconds = 120;

    public DefaultWorkerProcessFactory(
        LoggingManager loggingManager,
        MessagingServer server,
        ClassPathRegistry classPathRegistry,

	cpuManager      cpumanager.Manager
	memoryManager   memorymanager.Manager
	topologyManager topologymanager.Manager
}

func (i *internalContainerLifecycleImpl) PreStartContainer(pod *v1.Pod, container *v1.Container, containerID string) error {
	if i.cpuManager != nil {
		i.cpuManager.AddContainer(pod, container, containerID)
	}

	if i.memoryManager != nil {
		i.memoryManager.AddContainer(pod, container, containerID)
	}

See the License for the specific language governing permissions and
limitations under the License.
*/

package memorymanager

import (
	v1 "k8s.io/api/core/v1"
	"k8s.io/kubernetes/pkg/kubelet/cm/memorymanager/state"
	"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
)

// Type defines the policy type
type policyType string

    }
    def applicationClassesInSystemClassLoaderWorkerImplementationFactory = Mock(ApplicationClassesInSystemClassLoaderWorkerImplementationFactory)
    def outputEventListener = Mock(OutputEventListener)
    def memoryManager = Mock(MemoryManager)
    def versionDetector = Mock(JvmVersionDetector) {
        getJavaVersion(_) >> JavaVersion.VERSION_1_9
    }
    DefaultWorkerProcessBuilder builder = new DefaultWorkerProcessBuilder(javaExecHandleFactory,

                                                                    ListenerManager listenerManager,
                                                                    MemoryManager memoryManager,
                                                                    OsMemoryInfo memoryInfo,
                                                                    ClassPathRegistry classPathRegistry,

                doLast {
                    final CountDownLatch osNotification = new CountDownLatch(1)
                    final CountDownLatch jvmNotification = new CountDownLatch(1)

                    MemoryManager manager = services.get(MemoryManager.class)
                    manager.addListener(new JvmMemoryStatusListener() {
                        void onJvmMemoryStatus(JvmMemoryStatus memoryStatus) {

		allocatedCPUs := i.cpuManager.GetCPUAffinity(string(pod.UID), container.Name)
		if !allocatedCPUs.IsEmpty() {
			containerConfig.Linux.Resources.CpusetCpus = allocatedCPUs.String()
		}
	}

	if i.memoryManager != nil {
		numaNodes := i.memoryManager.GetMemoryNUMANodes(pod, container)
		if numaNodes.Len() > 0 {
			var affinity []string
			for _, numaNode := range sets.List(numaNodes) {
				affinity = append(affinity, strconv.Itoa(numaNode))
			}