Changeset 657 for trunk/kernel/libk/grdxt.c

Timestamp:

Mar 18, 2020, 11:16:59 PM (4 years ago)

Author:

alain

Message:

Introduce remote_buf.c/.h & socket.c/.h files.
Update dev_nic.c/.h files.

File:

• trunk/kernel/libk/grdxt.c (modified) (6 diffs)

trunk/kernel/libk/grdxt.c

@@ -332 +332 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
+////////////////////////////////////////////
+error_t grdxt_remote_init( xptr_t     rt_xp,
+                           uint32_t   ix1_width,
+                           uint32_t   ix2_width,
+                           uint32_t   ix3_width )
+{
+    void      ** root;
+        kmem_req_t   req;
+
+    // get cluster and local pointer
+    cxy_t     rt_cxy = GET_CXY( rt_xp );
+    grdxt_t * rt_ptr = GET_PTR( rt_xp );
+  
+    // initialize widths
+    hal_remote_s32( XPTR( rt_cxy , &rt_ptr->ix1_width ) , ix1_width );
+    hal_remote_s32( XPTR( rt_cxy , &rt_ptr->ix2_width ) , ix2_width );
+    hal_remote_s32( XPTR( rt_cxy , &rt_ptr->ix3_width ) , ix3_width );
+
+    // allocates first level array
+        req.type  = KMEM_KCM;
+        req.order = ix1_width + ( (sizeof(void*) == 4) ? 2 : 3 );
+        req.flags = AF_KERNEL | AF_ZERO;
+        root      = kmem_remote_alloc( rt_cxy , &req );
+
+        if( root == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot allocate first level array\n", __FUNCTION__);
+        return -1;
+    }
+  
+    // register first level array in rt descriptor
+    hal_remote_spt( XPTR( rt_cxy , &rt_ptr->root ) , root );
+ 
+        return 0;
+
+}  // end grdxt_remote_init()
+
+//////////////////////////////////////////
+void grdxt_remote_destroy( xptr_t  rt_xp )
+{
+        kmem_req_t req;
+
+    uint32_t   w1;
+    uint32_t   w2;
+    uint32_t   w3;
+
+        uint32_t   ix1;
+        uint32_t   ix2;
+        uint32_t   ix3;
+
+    void    ** ptr1;
+    void    ** ptr2;
+    void    ** ptr3;
+
+    // get cluster and local pointer
+    cxy_t     rt_cxy = GET_CXY( rt_xp );
+    grdxt_t * rt_ptr = GET_PTR( rt_xp );
+
+    // get widths
+    w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
+    w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
+    w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
+
+    // get ptr1
+    ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+
+        for( ix1=0 ; ix1 < (uint32_t)(1 << w1) ; ix1++ )
+        {
+        // get ptr2
+        ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+
+                if( ptr2 == NULL ) continue;
+
+        for( ix2=0 ; ix2 < (uint32_t)(1 << w2) ; ix2++ )
+        {
+            // get ptr2
+            ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+
+                    if( ptr3 == NULL ) continue;
+
+            for( ix3=0 ; ix3 < (uint32_t)(1 << w3) ; ix3++ )
+            {
+                 if( ptr3[ix3] != NULL )
+                 {
+                     printk("\n[WARNING] in %s : ptr3[%d][%d][%d] non empty\n",
+                     __FUNCTION__, ix1, ix2, ix3 );
+                 }
+            }
+
+            // release level 3 array 
+            req.type = KMEM_KCM;
+                    req.ptr  = ptr3;
+                    kmem_remote_free( rt_cxy , &req );
+        }
+
+        // release level 2 array
+        req.type = KMEM_KCM;
+                req.ptr  = ptr2;
+            kmem_remote_free( rt_cxy , &req );
+    }
+
+    // release level 1 array
+    req.type = KMEM_KCM;
+        req.ptr  = ptr1;
+    kmem_remote_free( rt_cxy , &req );
+
+}  // end grdxt_remote_destroy()
+
 //////////////////////////////////////////////
 error_t grdxt_remote_insert( xptr_t     rt_xp,
@@ -464 +572 @@
 
 ////////////////////////////////////////////
-void * grdxt_remote_remove( xptr_t    rt_xp,
+xptr_t grdxt_remote_remove( xptr_t    rt_xp,
                             uint32_t  key )
 {
@@ -489 +597 @@
     // get ptr2
         void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
-        if( ptr2 == NULL ) return NULL;
+        if( ptr2 == NULL ) return XPTR_NULL;
 
     // get ptr3
         void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
-        if( ptr3 == NULL ) return NULL;
+        if( ptr3 == NULL ) return XPTR_NULL;
 
     // get value
@@ -502 +610 @@
         hal_fence();
 
-        return value;
+        return XPTR( rt_cxy , value );
 
 }  // end grdxt_remote_remove()
@@ -523 +631 @@
 
     // compute indexes
-    uint32_t        ix1 = key >> (w2 + w3);              // index in level 1 array
-        uint32_t        ix2 = (key >> w3) & ((1 << w2) -1);  // index in level 2 array
-        uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
+    uint32_t       ix1 = key >> (w2 + w3);              // index in level 1 array
+        uint32_t       ix2 = (key >> w3) & ((1 << w2) -1);  // index in level 2 array
+        uint32_t       ix3 = key & ((1 << w3) - 1);         // index in level 3 array
 
     // get ptr1
@@ -546 +654 @@
 
 }  // end grdxt_remote_lookup()
+
+////////////////////////////////////////////////
+xptr_t grdxt_remote_get_first( xptr_t     rt_xp,
+                               uint32_t   start_key,
+                               uint32_t * found_key )
+{
+    uint32_t        ix1;
+    uint32_t        ix2;
+    uint32_t        ix3;
+
+    void        ** ptr1;       // local base address of remote first level array
+    void        ** ptr2;       // local base address of remote second level array
+    void        ** ptr3;       // local base address of remote third level array
+
+    // get cluster and local pointer on remote rt descriptor
+    grdxt_t       * rt_ptr = GET_PTR( rt_xp );
+    cxy_t           rt_cxy = GET_CXY( rt_xp );
+
+    // get widths
+    uint32_t        w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
+    uint32_t        w2 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix2_width ) );
+    uint32_t        w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
+
+// Check key value
+assert( ((start_key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", start_key );
+
+    // compute min indexes
+    uint32_t       min1 = start_key >> (w2 + w3);            
+        uint32_t       min2 = (start_key >> w3) & ((1 << w2) -1);
+        uint32_t       min3 = start_key & ((1 << w3) - 1);  
+
+    // compute max indexes
+    uint32_t       max1 = 1 << w1;
+    uint32_t       max2 = 1 << w2;
+    uint32_t       max3 = 1 << w3;
+
+    // get ptr1
+    ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+
+    for( ix1 = min1 ; ix1 < max1 ; ix1++ )
+    {
+        ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+        if( ptr2 == NULL ) continue;
+
+        for( ix2 = min2 ; ix2 < max2 ; ix2++ )
+        {
+            ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+            if( ptr3 == NULL ) continue;
+
+            for( ix3 = min3 ; ix3 < max3 ; ix3++ )
+            {
+                void * item = hal_remote_lpt( XPTR( rt_cxy , &ptr3[ix3] ) );
+
+                if( item == NULL ) continue;
+                else                    
+                {
+                    *found_key = (ix1 << (w2+w3)) | (ix2 << w3) | ix3;
+                    return XPTR( rt_cxy , item );
+                }
+            }
+        }
+    }
+
+    return XPTR_NULL;
+
+}  // end grdxt_remote_get_first()
 
 /////////////////////////i/////////////////