private final String workType;
    private final String identity;
    private final Map<String, List<ManifestEntry>> propertyManifests;

    public CacheManifest(OriginMetadata originMetadata, String workType, String identity, Map<String, List<ManifestEntry>> propertyManifests) {
        this.originMetadata = originMetadata;
        this.workType = workType;
        this.identity = identity;

                    .details(new ExecuteWorkDetails(workType, context.getIdentity().getUniqueId()))))
            .orElseGet(() -> delegate.execute(work, context));
    }

    private static class ExecuteWorkDetails implements ExecuteWorkBuildOperationType.Details {

        private final String workType;
        private final String identity;

        public ExecuteWorkDetails(String workType, String identity) {

        private final String workType;
        private final Identity identity;
        private final OriginMetadata originMetadata;

        public DefaultExecuteDeferredWorkProgressDetails(
            @Nullable String workType,
            Identity identity,
            OriginMetadata originMetadata
        ) {
            this.workType = workType;
            this.identity = identity;

    }

    public OriginWriter createWriter(String identity, Class<?> workType, HashCode buildCacheKey, Duration elapsedTime) {
        return outputStream -> {
            Properties properties = new Properties();
            properties.setProperty(BUILD_INVOCATION_ID_KEY, currentBuildInvocationId);
            properties.setProperty(TYPE_KEY, workType.getCanonicalName());
            properties.setProperty(IDENTITY_KEY, identity);

    }

    @Nonnull
    private IdentityContext createIdentityContext(UnitOfWork work, C context) {
        Class<? extends UnitOfWork> workType = work.getClass();
        return operation(operationContext -> {
                IdentityContext identityContext = createIdentityContextInternal(work, context);
                Identity identity = identityContext.getIdentity();

                            .documentedAt(userManual("validation_problems", "disable_caching_by_default"))
                            .severity(WARNING)
                            .details("The " + workType + " author should make clear why a " + workType + " is not cacheable")
                            .solution("Add " + disableCachingAnnotation + "(because = ...)")
                            .solution("Add " + cacheableAnnotation);

        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public Result execute(UnitOfWork work, C context) {
        Class<? extends UnitOfWork> workType = work.getClass();
        UnitOfWork.Identity identity = context.getIdentity();
        return buildOperationRunner.call(new CallableBuildOperation<Result>() {
            @Override

	select {
	case podUpdates <- struct{}{}:
	default:
	}

	if (becameTerminating || wasGracePeriodShortened) && status.cancelFn != nil {
		klog.V(3).InfoS("Cancelling current pod sync", "pod", klog.KRef(ns, name), "podUID", uid, "workType", status.WorkType())
		status.cancelFn()
		return
	}
}

	unsafe.Offsetof(heapStatsDelta{}.inWorkBufs),
	unsafe.Offsetof(lfnode{}.next),
	unsafe.Offsetof(mstats{}.last_gc_nanotime),
	unsafe.Offsetof(mstats{}.last_gc_unix),
	unsafe.Offsetof(workType{}.bytesMarked),
}

// AtomicVariables is the set of global variables on which we perform
// 64-bit atomic operations.
var AtomicVariables = []unsafe.Pointer{
	unsafe.Pointer(&ncgocall),
	unsafe.Pointer(&test_z64),

        });
        // It doesn't matter whether we use cacheable true or false, since none of the warnings depends on the cacheability of the task.
        Class<?> workType = workClass.get();
        TypeValidationContext workValidationContext = validationContext.forType(workType, true);
        validateImplementation(workValidationContext, beforeExecutionState.getImplementation(), "Implementation of ", work);