[Ofmfwg] OFMF attached Composability Manager with Use-Cases

[Christian Pinto]

Thanks Mike,

Using ResourceBlocks and the Resource Composition abstraction in Redfish is something we have discussed soon after we joined this group and it is totally in line with our point of view. At the time we got stuck with the discussion on who creates the resource blocks. The two options at the time were: The composition service infers them from the structure of the fabric or, the agents advertise all resources as resource blocks. We should restart this conversation to define these aspects because they would change the way agents register to the OFMF and advertise components.

On your use-cases I think they are ok but I do not understand the alternate flow depicting a situation when the resources are “not local to the requesting client”. What do you mean with a resource being local to a client requestor? I only see remote/local to apply here from the CPU perspective. i.e., the memory is remote (through fabric) to the CPU, etc.

Christian

Christian Pinto, Ph.D.
Research Scientist
IBM Research Europe - Ireland


From: Ofmfwg <ofmfwg-bounces at lists.openfabrics.org> on behalf of Aguilar, Michael J. <mjaguil at sandia.gov>
Date: Tuesday, 21 February 2023 at 17:15
To: ofmfwg at lists.openfabrics.org <ofmfwg at lists.openfabrics.org>, Cayton, Phil <phil.cayton at intel.com>, Ahlvers, Richelle <richelle.ahlvers at intel.com>, Jim Hull <jmhull at intelliprop.com>, Blagodurov, Sergey <Sergey.Blagodurov at amd.com>, Hojati, Elham <elham.hojati at intel.com>, Apostal, David <david.apostal at und.edu>
Subject: [EXTERNAL] [Ofmfwg] OFMF attached Composability Manager with Use-Cases
Everyone Over the weekend, and last night, I started working up the Agent Frameworks, Aggregators (not much for documentation), and a Composability Manager. They all seem to link back-and-forth, together. Anyway, I managed to be able to put
ZjQcmQRYFpfptBannerStart
This Message Is From an External Sender
This message came from outside your organization.
ZjQcmQRYFpfptBannerEnd
Everyone

Over the weekend, and last night, I started working up the Agent Frameworks, Aggregators (not much for documentation), and a Composability Manager.  They all seem to link back-and-forth, together.   Anyway, I managed to be able to put together the initial framework for the Composability Manager, in some basic Use-Cases.

Mike

Nomenclature:


A constrained composition is when a client has identified a set of criteria, or constraints, in which to build a logical entity. This includes criteria such as quantities of components, or characteristics of components

An expandable resource is when a service has a baseline composition that cannot be removed. Instead of a client making requests to create a composed resource, a client can only add or remove resources from the composed resource

A service that supports composability shall implement resource blocks, defined by the ResourceBlock schema, and resource zones, defined in the Zone schema, for the composition service. Resource blocks provide an inventory of components available to the client for building compositions. Resource zones describe the binding restrictions of the resource blocks that the service manages.

The resource zones within the composition service shall include the collection capabilities annotation<https://redfish.dmtf.org/schemas/DSP0266_1.16.0.html#collection-capabilities-annotation> in responses. The collection capabilities annotation allows a client to discover which resource collections in the service support compositions, the different composition request<https://redfish.dmtf.org/schemas/DSP0266_1.16.0.html#composition-requests> types allowed, how the POST request for the resource collection is formatted, and which properties are required.


Use-Case 1:  A fully composed HPC node


Use-Case Description
Composability Manager—Create a Constrained Composition of a node
Actors
Composability Manager, OFMF, Resource Zones, Free Pool, Active Pool, Constraints, Members
Description
Assemble a composed HPC node using resources out of the Free Pool
Input Data
Client requirements:  CPU architecture, Memory Device Type, Storage Capacity, Storage Type, Accelerator Type, Network Interface Types
Pre Conditions
OFMF contains a Free pool of Resources, network Agents active
Post Conditions
Composed Turing Compatible System from Free Pool, Active Pool incremented by Composed Resources
Trigger
Client request for fully Composed Resources
Normal Flow

  *   Receive Client Requirements
  *   GET current Free Pool resources from the OFMF
  *   Create a framework package of JSON Constrained requirements, using the Client Requirements and the available Free Pool Resources
     *   Create JSON
        *   CPU
           *   Type of CPU(s)
           *   Quantity of CPU(s)
        *   Memory
           *   Type of Memory
           *   Amount of Memory
        *   Storage
           *   Type of Storage
        *   Resource endpoints
           *   What network links are available?
           *   What networks?
           *   Aggregated?
  *   Associate Components with links into the Redfish Tree
  *   POST Constrained Composable JSON to the OFMF
     *   Post of Free Resources to /redfish/v1/CompositionService/ResourceZones and /redfish/v1/CompositionService/ResourceBlocks
  *   POST used resources to Active Resources
  *   Return success
Alternate Flow

  *   Receive Client Requirements
  *   GET current Free Pool resources from the OFMF
  *   Resources don’t exist to fulfill requirements
  *   Return failure
Alternate Flow 2

  *   Receive Client Requirements
  *   GET current Free Pool resources from the OFMF
  *   Resources don’t exist locally to the client requestor
  *   Warning to the client that the requested resources are remote
  *   Create a framework package of JSON Constrained requirements, using the Client Requirements and the available Free Pool Resources
     *   Create JSON
        *   CPU
           *   Type of CPU(s)
           *   Quantity of CPU(s)
        *   Memory
           *   Type of Memory
           *   Amount of Memory
        *   Storage
           *   Type of Storage
        *   Resource endpoints
           *   What network links are available?
           *   What networks?
           *   Aggregated?
  *   Associate Components with links into the Redfish Tree
  *   POST Constrained Composable JSON to the OFMF
     *   Post of Free Resources to /redfish/v1/CompositionService/ResourceZones and /redfish/v1/CompositionService/ResourceBlocks
  *   POST used resources to Active Resources
  *   Return success


Use-Case 1:  An Expanded set of resources added to an HPC node


Use-Case Description
Composability Manager—Add to an Expandable Resource
Actors
Composability Manager, OFMF, Resource Zones, Free Pool, Active Pool, Constraints, Members
Description
Add resources from the Free Pool to an existing HPC node Chassis
Input Data
Current node chassis resources, Client requirements:  CPU architecture, Memory Device Type, Storage Capacity, Storage Type, Accelerator Type, Network Interface Types
Pre Conditions
Free Pool, network Agents active, actions on the composed resource for adding and removing resource blocks
Post Conditions
Composed Turing Compatible System from Free Pool and HPC node chassis, Active Pool incremented by Composed Resources
Trigger
Client request for fully Composed Resources to prevent run-time failure or to augment node resources
Normal Flow

  *   Receive Client Requirements
  *   GET current node resources from the OFMF
  *   GET current Free Pool resources from the OFMF
  *   Create a framework package of JSON Constrained requirements, using the Client Requirements over the node requirements and the available Free Pool Resources
     *   Create JSON
        *   CPU
           *   Type of CPU(s)
           *   Quantity of CPU(s)
        *   Memory
           *   Type of Memory
           *   Amount of Memory
        *   Storage
           *   Type of Storage
        *   Resource endpoints
           *   What network links are available?
           *   What networks?
           *   Aggregated?
  *   Associate Components with links into the Redfish Tree
  *   POST Constrained Composable JSON to the OFMF
     *   Post of Free Resources to /redfish/v1/CompositionService/ResourceZones and /redfish/v1/CompositionService/ResourceBlocks
  *   POST used resources to Active Resources
  *   Return success
Alternate Flow 1

  *   Receive Client Requirements
  *   GET current node resources from the OFMF
  *   GET current Free Pool resources from the OFMF
  *   Free Pool resources are not available to match the over the node requirements
  *   Return failure
Alternate Flow 2

  *   Receive Client Requirements
  *   GET current node resources from the OFMF
  *   GET current Free Pool resources from the OFMF
  *   Free Pool resources are remote to the node
  *   Send warning to client stating that the new attached resources are remote
  *   Create a framework package of JSON Constrained requirements, using the Client Requirements over the node requirements and the available Free Pool Resources
     *   Create JSON
        *   CPU
           *   Type of CPU(s)
           *   Quantity of CPU(s)
        *   Memory
           *   Type of Memory
           *   Amount of Memory
        *   Storage
           *   Type of Storage
        *   Resource endpoints
           *   What network links are available?
           *   What networks?
           *   Aggregated?
  *   Associate Components with links into the Redfish Tree
  *   POST Constrained Composable JSON to the OFMF
     *   Post of Free Resources to /redfish/v1/CompositionService/ResourceZones and /redfish/v1/CompositionService/ResourceBlocks
  *   POST used resources to Active Resources
  *   Return success

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.openfabrics.org/pipermail/ofmfwg/attachments/20230224/ff8ee8ff/attachment-0001.htm>