source: trunk/kernel/kern/cluster.h @ 687

Last change on this file since 687 was 683, checked in by alain, 4 years ago

All modifications required to support the <tcp_chat> application
including error recovery in case of packet loss.A
File size: 17.5 KB
RevLine 
[1]1/*
2 * cluster.h - Cluster-Manager definition
[19]3 *
[683]4 * authors  Ghassan Almaless       (2008,2009,2010,2011,2012)
[1]5 *          Mohamed Lamine Karaoui (2015)
[683]6 *          Alain Greiner          (2016,2017,2018,2019,2020)
[1]7 *
8 * Copyright (c) UPMC Sorbonne Universites
9 *
10 * This file is part of ALMOS-MKH.
11 *
12 * ALMOS-MKH is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; version 2.0 of the License.
15 *
16 * ALMOS-MKH is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
23 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 */
25
26#ifndef _CLUSTER_H_
27#define _CLUSTER_H_
28
[14]29#include <kernel_config.h>
[457]30#include <hal_kernel_types.h>
[1]31#include <bits.h>
[564]32#include <queuelock.h>
33#include <remote_queuelock.h>
[1]34#include <list.h>
35#include <xlist.h>
36#include <dqdt.h>
37#include <kmem.h>
38#include <hal_atomic.h>
39#include <ppm.h>
40#include <kcm.h>
41#include <rpc.h>
42#include <core.h>
43#include <process.h>
44
45/**** Forward declarations  ****/
46
47struct core_s;
48struct process_s;
49
50
51/*******************************************************************************************
52 * This structure defines the process manager, that is part of the cluster manager.
53 * For any process P, the process descriptor is replicated in all clusters containing
[19]54 * at least one thread of process P, but only the "reference" cluster descriptor contains
[23]55 * the reference (complete) GPT, VSL, and FDT structures.
56 * The "owner" cluster K is in charge to allocate a lpid (local process index),
57 * to the owned processes, and to register the "reference" cluster for these processes.
[1]58 *
[19]59 * Warning : the "owner" cluster, and the "reference" cluster can be different clusters.
[1]60 *
[443]61 * The process manager of a cluster K maintains three sets of process descriptors:
62 *
63 * 1) pref_tbl[] is an array indexed by lpid. There is one entry per owned process.
[1]64 *    Each entry contains an extended pointer on the reference process descriptor.
[23]65 *
[443]66 * 2) The local_root is the root of the local list of all process descriptors in cluster K.
[1]67 *    A process descriptor P is present in K, as soon as P has a thread in cluster K.
[564]68 *    We use an xlist, because this list can be traversed by remote threads.
[23]69 *
70 * 3) The copies_root[] array is indexed by lpid. There is one entry per owned process,
71 *    and each each entry contains the root of the xlist of copies for this process.
[564]72 $    We use an xlist, because process copies are distributed in all clusters.
[1]73 ******************************************************************************************/
74
75typedef struct process_manager_s
76{
[564]77        xptr_t             pref_tbl[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! owned  processes    */
78        queuelock_t        pref_lock;              /*! lock protecting pref_tbl               */
79    uint32_t           pref_nr;                /*! number of processes owned by cluster   */
[1]80
[564]81    xlist_entry_t      local_root;            /*! root of list of process in cluster      */
82    remote_queuelock_t local_lock;            /*! lock protecting local list              */
83    uint32_t           local_nr;              /*! number of process in cluster            */
[1]84
[564]85    xlist_entry_t      copies_root[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! roots of lists   */
86    remote_queuelock_t copies_lock[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! one  per list    */
87    uint32_t           copies_nr[CONFIG_MAX_PROCESS_PER_CLUSTER];    /*! number of copie  */
[1]88}
89pmgr_t;
90
91/*******************************************************************************************
92 * This structure defines a cluster manager.
[19]93 * It contains both global platform information, and cluster specific resources
[279]94 * controled by the local kernel instance.
[1]95 ******************************************************************************************/
96
97typedef struct cluster_s
98{
99
100    // global parameters
[564]101    uint32_t        paddr_width;       /*! numer of bits in physical address              */
[440]102    uint32_t        x_width;           /*! number of bits to code x_size  (can be 0)      */
103    uint32_t        y_width;           /*! number of bits to code y_size  (can be 0)      */
[564]104    uint32_t        x_size;            /*! number of clusters in a row    (can be 1)      */
105    uint32_t        y_size;            /*! number of clusters in a column (can be 1)      */
[683]106    uint32_t        io_cxy;            /*! io cluster identifier                          */
107    uint32_t        sys_clk;           /*! system_clock frequency (in Hertz)              */
[440]108    uint32_t        dqdt_root_level;   /*! index of root node in dqdt_tbl[]               */
109    uint32_t        nb_txt_channels;   /*! number of TXT channels                         */
110    uint32_t        nb_nic_channels;   /*! number of NIC channels                         */
111    uint32_t        nb_ioc_channels;   /*! number of IOC channels                         */
112    uint32_t        nb_fbf_channels;   /*! number of FBF channels                         */
[1]113
[637]114    // number of cores for each cluster in the mesh
115    uint8_t         cluster_info[CONFIG_MAX_CLUSTERS_X][CONFIG_MAX_CLUSTERS_Y];
[564]116
[1]117    // local parameters
[564]118    uint32_t        cores_nr;          /*! actual number of cores in cluster              */
[440]119    uint32_t        ram_size;          /*! physical memory size                           */
120    uint32_t        ram_base;          /*! physical memory base (local address)           */
[279]121
[440]122        core_t          core_tbl[CONFIG_MAX_LOCAL_CORES];    /*! embedded cores               */
[1]123
[564]124    list_entry_t    dev_root;          /*! root of list of devices in cluster             */
[279]125
[683]126    // physical memory allocators: one PPM and severa KCM
127    ppm_t           ppm;
128    kcm_t           kcm[CONFIG_PPM_PAGE_ORDER - CONFIG_CACHE_LINE_ORDER];
[428]129
[279]130    // RPC
[564]131    remote_fifo_t   rpc_fifo[CONFIG_MAX_LOCAL_CORES];    /*! one RPC FIFO per core        */
[440]132    uint32_t        rpc_threads[CONFIG_MAX_LOCAL_CORES]; /*! RPC threads per core         */
[1]133
[279]134    // DQDT
[564]135    dqdt_node_t     dqdt_tbl[CONFIG_DQDT_LEVELS_NR];     /*! embedded DQDT nodes          */
[1]136
[582]137    xptr_t          dqdt_root_xp;      /*! extended pointer on DQDT root node             */
138
[279]139    // Local process manager
[440]140    pmgr_t          pmgr;              /*! embedded process manager                       */
[188]141
[440]142    void          * pic_extend;        /*! PIC implementation specific extension          */
[19]143}
[1]144cluster_t;
145
146/******************************************************************************************
147 * This global variable is allocated in the kernel_init.c file.
[19]148 * There is one cluster_manager per cluster, with the same local address,
149 * but different content, in all clusters containing a kernel instance.
[1]150 *****************************************************************************************/
151
152extern cluster_t cluster_manager;
153
154/******************************************************************************************
155 * This macro returns a local pointer on the local cluster manager.
156 *****************************************************************************************/
157
158#define LOCAL_CLUSTER    (&cluster_manager)
159
160/******************************************************************************************
[564]161 * These two functions initialise the local cluster manager from information found
162 * in the local boot-info structure <info> build by the boot-loader.
163 * 1) the cluster_info_init() function is called first, to initialize the structural
[637]164 *    constants, including the cluster_info[x][y] array.
165 *    It cannot use the TXT0 kernel terminal.
166 * 2) the cluster_manager_init() function initializes various complex structures:
[564]167 *    - the local DQDT nodes,
168 *    - the PPM, KHM, and KCM allocators,
169 *    - the local core descriptors,
170 *    - the local RPC FIFO,
171 *    - the process manager.
172 *    It can use the TXT0 kernel terminal.
[1]173 ******************************************************************************************
174 * @ info : pointer on the local boot_info_t structure build by the bootloader.
175 *****************************************************************************************/
[564]176void    cluster_info_init( boot_info_t * info );
177error_t cluster_manager_init( boot_info_t * info );
[1]178
179/******************************************************************************************
[637]180 * This debug function displays the current values stored in the cluster_info[][] array
181 * of a remote cluster identified by the <cxy> argument.
182 * It can be called by a thread running in any cluster.
[1]183 ******************************************************************************************
[637]184 * @ cxy   : remote cluster identifier.
[1]185 *****************************************************************************************/
[637]186void cluster_info_display( cxy_t  cxy );
[1]187
[564]188/******************************************************************************************
[637]189 * This function access the local cluster_info[][] array and returns true when the
190 * cluster identified by the <cxy> argument is active (contains a kernel instance).
[564]191 ******************************************************************************************
[637]192 * @ cxy   : checked cluster identifier.
[564]193 * @ return true if cluster contains a kernel instance.
194 *****************************************************************************************/
195bool_t cluster_is_active( cxy_t  cxy );
[1]196
[564]197/******************************************************************************************
[657]198 * This function selects (pseudo) randomly a valid cluster.
[564]199 * It is called by the vfs_cluster_lookup() function to place a new (missing) inode.
200 * It is called by the vmm_page_allocate() function to place a distributed vseg page.
[657]201 * It is called by the dev_nic_accept() function to place a new server socket.
[564]202 ******************************************************************************************
203 * @ returns the selected cluster identifier.
204 *****************************************************************************************/
205cxy_t cluster_random_select( void );
[1]206
207/******************************************************************************************
[433]208 * This function returns an extended pointer on the process descriptor in owner cluster
[443]209 * from the process <pid>. This PID can be be different from the calling process PID.
[433]210 * It can be called by any thread running in any cluster,
211 ******************************************************************************************
212 * @ pid  : process identifier.
213 * @ return extended pointer on owner process if found / XPTR_NULL if not found.
214 *****************************************************************************************/
215xptr_t cluster_get_owner_process_from_pid( pid_t pid );
216
217/******************************************************************************************
[1]218 * This function returns an extended pointer on the reference process descriptor
[443]219 * from the process <pid>. This PID can be be different from the calling process PID.
[23]220 * It can be called by any thread running in any cluster,
[1]221 ******************************************************************************************
222 * @ pid  : process identifier.
[433]223 * @ return extended pointer on reference process if found / XPTR_NULL if not found.
[1]224 *****************************************************************************************/
225xptr_t cluster_get_reference_process_from_pid( pid_t pid );
226
[19]227/******************************************************************************************
[443]228 * This function returns an extended pointer on the process descriptor copy for the
229 * process identified by <pid> in cluster defined by <cxy> argument.
230 * This PID can be be different from the calling process PID.
231 * It can be called by any thread running in any cluster,
232 ******************************************************************************************
233 * @ cxy  : target cluster identifier.
234 * @ pid  : process identifier.
235 * @ return extended pointer on reference process if found / XPTR_NULL if not found.
236 *****************************************************************************************/
237xptr_t cluster_get_process_from_pid_in_cxy( cxy_t cxy,
238                                            pid_t pid );
239
240/******************************************************************************************
[1]241 * This function allocates a new PID in local cluster, that becomes the process owner.
[19]242 * It registers the process descriptor extended pointer in the local processs manager
[428]243 * pref_tbl[] array. The process descriptor itself is not modified.
244 * This function is called by the process_make_fork() function,
[416]245 * by the process_make_exec() function, and by the process_init_create() function.
[1]246 ******************************************************************************************
[416]247 * @ process    : pointer on process descriptor.
[1]248 * @ pid        : [out] allocated PID.
[416]249 * @ return 0 if success / return -1 if no PID slot available.
[1]250 *****************************************************************************************/
[416]251error_t cluster_pid_alloc( struct process_s * process,
252                           pid_t            * pid );
[1]253
[19]254/******************************************************************************************
[1]255 * This function removes a PID from the local process manager pref_tbl[] array.
256 * It checks that removed process is owned by the local cluster and the lpid is legal.
257 * No memory is released by this function.
258 ******************************************************************************************
259 * @ pid        : allocated PID.
260 *****************************************************************************************/
261void cluster_pid_release( pid_t  pid );
262
263/******************************************************************************************
264 * This function returns a pointer on the local process descriptor from the PID.
265 ******************************************************************************************
266 * @ pid     : searched process identifier.
267 * @ returns process descriptor pointer if found / returns NULL if not found.
268 *****************************************************************************************/
269struct process_s * cluster_get_local_process_from_pid( pid_t pid );
270
271/******************************************************************************************
272 * This function registers a local process descriptor in the process manager local_list.
273 ******************************************************************************************
274 * @ process     : pointer on local process descriptor.
275 *****************************************************************************************/
[19]276void cluster_process_local_link( struct process_s * process );
[1]277
278/******************************************************************************************
279 * This function removes a local process descriptor from the process manager local_list.
280 ******************************************************************************************
281 * @ process     : pointer on local process descriptor.
282 *****************************************************************************************/
[19]283void cluster_process_local_unlink( struct process_s * process );
[1]284
285/******************************************************************************************
286 * This function registers a local process descriptor in the owner process manager
287 * copies_list, that can be in a remote cluster.
288 ******************************************************************************************
289 * @ process     : pointer on local process descriptor.
290 *****************************************************************************************/
[19]291void cluster_process_copies_link( struct process_s * process );
[1]292
293/******************************************************************************************
294 * This function removes a local process descriptor from the owner process manager
295 * copies_list, that can be in a remote cluster.
296 ******************************************************************************************
297 * @ process     : pointer on local process descriptor.
298 *****************************************************************************************/
[19]299void cluster_process_copies_unlink( struct process_s * process );
[1]300
[564]301/******************************************************************************************
[428]302 * This function displays on the kernel terminal TXT0 all user processes registered
303 * in the cluster defined by the <cxy> argument.
[637]304 * It can be called by a thread running in any cluster.
[564]305 ******************************************************************************************
[428]306 * @ cxy   : cluster identifier.
[583]307 * @ owned : only owned process if non zero.
[564]308 *****************************************************************************************/
[583]309void cluster_processes_display( cxy_t   cxy,
310                                bool_t  owned );
[1]311
312/******************************************************************************************
[637]313 * This function selects the core that has the lowest usage in a - possibly remote -
314 * cluster identified by the <cxy> argument.
315 * It can be called by a thread running in any cluster.
316 ******************************************************************************************
317 * @ cxy    : target cluster identifier.
318 * @ return the selected core local index.
[1]319 *****************************************************************************************/
[637]320lid_t cluster_select_local_core( cxy_t  cxy );
[1]321
[564]322             
[1]323#endif  /* _CLUSTER_H_ */
[564]324
Note: See TracBrowser for help on using the repository browser.