Changeset 683 for trunk/kernel/mm/kmem.h

Timestamp:

Jan 13, 2021, 12:36:17 AM (3 years ago)

Author:

alain

Message:

All modifications required to support the <tcp_chat> application
including error recovery in case of packet loss.A

File:

• trunk/kernel/mm/kmem.h (modified) (3 diffs)

trunk/kernel/mm/kmem.h

@@ -1 +1 @@
 /*
- * kmem.h - kernel unified memory allocator interface
+ * kmem.h - unified kernel memory allocator definition
  *
- * Authors  Alain Greiner (2016,2017,2018,2019)
+ * Authors  Alain Greiner     (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -29 +29 @@
 
 /*************************************************************************************
- * This enum defines the three Kernel Memory Allocaror types 
- ************************************************************************************/
-
-enum
-{
-    KMEM_PPM              = 0,   /*! PPM allocator                                  */
-    KMEM_KCM              = 1,   /*! KCM allocator                                  */
-    KMEM_KHM              = 2,   /*! KHM allocator                                  */
-};
-
-/*************************************************************************************
  * This defines the generic Allocation Flags that can be associated to
  * a Kernel Memory Request.
@@ -45 +34 @@
 
 #define AF_NONE       0x0000   // no attributes
-#define AF_KERNEL     0x0001   // for kernel use
-#define AF_ZERO       0x0002   // must be reset to 0
-
-/*************************************************************************************
- * This structure defines a Kernel Memory Request.
- ************************************************************************************/
-
-typedef struct kmem_req_s
-{
-    uint32_t      type;   /*! KMEM_PPM / KMEM_KCM / KMEM_KHM                        */
-    uint32_t      order;  /*! PPM: ln2(pages) / KCM: ln2(bytes) / KHM: bytes        */
-    uint32_t      flags;  /*! request attributes                                    */
-    void        * ptr;    /*! local pointer on allocated buffer (only used by free) */
-}
-kmem_req_t;
+#define AF_KERNEL     0x0001   // for kernel use ???
+#define AF_ZERO       0x0002   // data buffer must be reset to 0
 
 /*************************************************************************************
  * These two functions allocate physical memory in a local or remote cluster
- * as specified by the kmem_req_t request descriptor, and return a local pointer
- * on the allocated buffer. It uses three specialised physical memory allocators:
- * - PPM (Physical Pages Manager) allocates N contiguous small physical pages.
- *       N is a power of 2, and req.order = ln(N). Implement the buddy algorithm.
- * - KCM (Kernel Cache Manager) allocates aligned blocks of M bytes from a cache.
- *       M is a power of 2, and req.order = ln( M ). One cache per block size.
- * - KHM (Kernel Heap Manager) allocates physical memory buffers of M bytes,
- *       M can have any value, and req.order = M.
- *
- * WARNING: the physical memory allocated with a given allocator type must be
- *          released using the same allocator type.
+ * as specified by the <cxy>, <order> and <flags> arguments, and return a local
+ * pointer on the allocated buffer. The buffer size (in bytes) is a power of 2,
+ * equal to (1 << order) bytes. It can be initialized to zero if requested.
+ * Depending on the <order> value, it uses two specialised allocators:
+ * - When order is larger or equal to CONFIG_PPM_PAGE_ORDER, the PPM (Physical Pages
+ *   Manager) allocates 2**(order - PPM_PAGE_ORDER) contiguous small physical pages.
+ *   This allocator implements the buddy algorithm.
+ * - When order is smaller than CONFIG_PPM_PAGE_ORDER, the KCM (Kernel Cache Manager) 
+ *   allocates an aligned block of 2**order bytes from specialised KCM[ORDER] caches
+ *  (one KCM cache per block size).  
  *************************************************************************************
- * @ cxy   : target cluster identifier for a remote access.
- * @ req   : local pointer on allocation request.
+ * @ cxy    : [in] target cluster identifier for a remote access).
+ * @ order  : [in] ln( block size in bytes).
+ * @ flags  : [in] allocation flags defined above.
  * @ return local pointer on allocated buffer if success / return NULL if no memory.
  ************************************************************************************/
-void * kmem_alloc( kmem_req_t * req );
+void * kmem_alloc( uint32_t  order,
+                   uint32_t  flags );
 
-void * kmem_remote_alloc( cxy_t        cxy,
-                          kmem_req_t * req );
+void * kmem_remote_alloc( cxy_t     cxy,
+                          uint32_t  order,
+                          uint32_t  flags );
 
 /*************************************************************************************
- * These two functions release previously allocated physical memory, as specified
- * by the <type> and <ptr> fields of the kmem_req_t request descriptor.
+ * These two functions release a previously allocated physical memory block,
+ * as specified by the <cxy>, <order> and <ptr> arguments. 
+ * - When order is larger or equal to CONFIG_PPM_PAGE_ORDER, the PPM (Physical Pages
+ *   Manager) releases 2**(order - PPM_PAGE_ORDER) contiguous small physical pages.
+ *   This allocator implements the buddy algorithm.
+ * - When order is smaller than CONFIG_PPM_PAGE_ORDER, the KCM (Kernel Cache Manager)
+ *   release release the block of 2**order bytes to the specialised KCM[order] cache.
  *************************************************************************************
- * @ cxy   : target cluster identifier for a remote access.
- * @ req : local pointer to request descriptor.
+ * @ cxy    : [in] target cluster identifier for a remote access.
+ * @ ptr    : [in] local pointer to released block.
+ * @ order  : [in] ln( block size in bytes ).
  ************************************************************************************/
-void  kmem_free ( kmem_req_t * req );
+void  kmem_free( void    * ptr,
+                 uint32_t  order );
 
-void  kmem_remote_free( cxy_t        cxy,
-                        kmem_req_t * req );
+void  kmem_remote_free( cxy_t     cxy,
+                        void    * ptr,
+                        uint32_t  order );