ocarina-backends-pok_c-deployment.adb 130 KB
Newer Older
1
2
3
4
5
6
7
8
------------------------------------------------------------------------------
--                                                                          --
--                           OCARINA COMPONENTS                             --
--                                                                          --
--    O C A R I N A . B A C K E N D S . P O K _ C . D E P L O Y M E N T     --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
9
--    Copyright (C) 2008-2009 Telecom ParisTech, 2010-2014 ESA & ISAE.      --
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
--                                                                          --
-- Ocarina  is free software;  you  can  redistribute  it and/or  modify    --
-- it under terms of the GNU General Public License as published by the     --
-- Free Software Foundation; either version 2, or (at your option) any      --
-- later version. Ocarina is distributed  in  the  hope  that it will be    --
-- useful, but WITHOUT ANY WARRANTY;  without even the implied warranty of  --
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General --
-- Public License for more details. You should have received  a copy of the --
-- GNU General Public License distributed with Ocarina; see file COPYING.   --
-- If not, write to the Free Software Foundation, 51 Franklin Street, Fifth --
-- Floor, Boston, MA 02111-1301, USA.                                       --
--                                                                          --
-- As a special exception,  if other files  instantiate  generics from this --
-- unit, or you link  this unit with other files  to produce an executable, --
-- this  unit  does not  by itself cause  the resulting  executable to be   --
-- covered  by the  GNU  General  Public  License. This exception does not  --
-- however invalidate  any other reasons why the executable file might be   --
-- covered by the GNU Public License.                                       --
--                                                                          --
jhugues's avatar
jhugues committed
29
30
--                 Ocarina is maintained by the TASTE project               --
--                      (taste-users@lists.tuxfamily.org)                   --
31
32
33
--                                                                          --
------------------------------------------------------------------------------

34
with Ocarina.Namet;
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
with Utils; use Utils;
with Locations;

with Ocarina.Backends.Properties;
with Ocarina.Backends.Messages;
with Ocarina.Backends.Utils;
with Ocarina.Backends.C_Tree.Nutils;
with Ocarina.Backends.C_Tree.Nodes;
with Ocarina.Backends.C_Values;
with Ocarina.Backends.POK_C.Runtime;
with Ocarina.Backends.C_Common.Mapping;

with Ocarina.Instances.Queries;

with Ocarina.ME_AADL;
with Ocarina.ME_AADL.AADL_Tree.Nodes;
with Ocarina.ME_AADL.AADL_Tree.Nutils;
with Ocarina.ME_AADL.AADL_Tree.Entities;
with Ocarina.ME_AADL.AADL_Instances.Nodes;
with Ocarina.ME_AADL.AADL_Instances.Nutils;
with Ocarina.ME_AADL.AADL_Instances.Entities;
with Ocarina.ME_AADL.AADL_Instances.Entities.Properties;

package body Ocarina.Backends.POK_C.Deployment is

60
   use Ocarina.Namet;
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
   use Locations;
   use Ocarina.Backends.Properties;
   use Ocarina.Backends.Messages;
   use Ocarina.Backends.Utils;
   use Ocarina.Backends.C_Tree.Nutils;
   use Ocarina.Backends.POK_C.Runtime;
   use Ocarina.Backends.C_Common.Mapping;
   use Ocarina.Instances.Queries;
   use Ocarina.ME_AADL;
   use Ocarina.ME_AADL.AADL_Instances.Nodes;
   use Ocarina.ME_AADL.AADL_Instances.Entities;

   package ATE renames Ocarina.ME_AADL.AADL_Tree.Entities;
   package ATN renames Ocarina.ME_AADL.AADL_Tree.Nodes;
   package ATNU renames Ocarina.ME_AADL.AADL_Tree.Nutils;
   package AIE renames Ocarina.ME_AADL.AADL_Instances.Entities;
   package AIN renames Ocarina.ME_AADL.AADL_Instances.Nodes;
   package AIEP renames Ocarina.ME_AADL.AADL_Instances.Entities.Properties;
   package AINU renames Ocarina.ME_AADL.AADL_Instances.Nutils;
   package CTU renames Ocarina.Backends.C_Tree.Nutils;
   package CTN renames Ocarina.Backends.C_Tree.Nodes;
82
83
84
85
86
87
88
89
90
91
92
   package CV renames Ocarina.Backends.C_Values;

   Array_Global_Ports_Nodes          : Node_Id;
   Array_Local_Ports_To_Global_Ports : Node_Id;
   Array_Global_Ports_To_Local_Ports : Node_Id;
   Array_Global_Ports_Bus            : Node_Id;
   Array_Buses_Partitions            : Node_Id;
   All_Ports                         : List_Id;
   Used_Buses                        : List_Id;
   Node_Identifier                   : Unsigned_Long_Long := 0;
   Current_Device                    : Node_Id            := No_Node;
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

   --------------------
   -- Is_Bus_Handled --
   --------------------

   function Is_Bus_Handled (Bus : Node_Id) return Boolean is
      S : Node_Id;
   begin
      if not AINU.Is_Empty (Used_Buses) then
         S := AIN.First_Node (Used_Buses);
         while Present (S) loop
            if (Item (S) = Bus) then
               return True;
            end if;
            S := AIN.Next_Node (S);
         end loop;

      end if;

      return False;
   end Is_Bus_Handled;

   ------------------------------
   -- Handle_Buses_Connections --
   ------------------------------

   procedure Handle_Buses_Connections (Port : Node_Id) is
120
121
      L          : List_Id;
      S          : Node_Id;
122
123
124
125
126
127
128
      Connection : Node_Id;

      procedure Handle_Bus (My_Bus : Node_Id) is
         Bus : Node_Id;
      begin
         Bus := My_Bus;

129
         if AINU.Is_Bus (Bus) and then not Is_Bus_Handled (Bus) then
130
            AINU.Append_Node_To_List
131
132
              (AINU.Make_Node_Container (Bus),
               Used_Buses);
133
134
135
         elsif AINU.Is_Virtual_Bus (Bus) then

            Bus := Parent_Component (Parent_Subcomponent (Bus));
136
            if AINU.Is_Bus (Bus) and then not Is_Bus_Handled (Bus) then
137
               AINU.Append_Node_To_List
138
139
                 (AINU.Make_Node_Container (Bus),
                  Used_Buses);
140
141
142
143
144
145
146
147
148
149
150
            end if;
         end if;
      end Handle_Bus;
   begin
      if AIN.Is_In (Port) then
         L := Sources (Port);
         if not AINU.Is_Empty (L) then
            S := AIN.First_Node (L);
            while Present (S) loop
               Connection := Extra_Item (S);

151
152
153
               if Present (Connection)
                 and then Get_Bound_Bus (Connection, False) /= No_Node
               then
154
155
156
157
158
159
160
161
162
163
164
165
166
                  Handle_Bus (Get_Bound_Bus (Connection, False));
               end if;

               S := AIN.Next_Node (S);
            end loop;
         end if;
      elsif AIN.Is_Out (Port) then
         L := Destinations (Port);
         if not AINU.Is_Empty (L) then
            S := AIN.First_Node (L);
            while Present (S) loop
               Connection := Extra_Item (S);

167
168
169
               if Present (Connection)
                 and then Get_Bound_Bus (Connection, False) /= No_Node
               then
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
                  Handle_Bus (Get_Bound_Bus (Connection, False));
               end if;

               S := AIN.Next_Node (S);
            end loop;
         end if;
      end if;
   end Handle_Buses_Connections;

   -------------
   -- Get_Bus --
   -------------

   function Get_Bus (Port : Node_Id) return Node_Id is
      L          : List_Id;
      S          : Node_Id;
      Bus        : Node_Id;
      Connection : Node_Id;
   begin
      if AIN.Is_In (Port) then
         L := Sources (Port);
         if not AINU.Is_Empty (L) then
            S := AIN.First_Node (L);
            while Present (S) loop
               Connection := Extra_Item (S);

196
197
198
               if Present (Connection)
                 and then Get_Bound_Bus (Connection, False) /= No_Node
               then
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
                  Bus := Get_Bound_Bus (Connection, False);

                  if AINU.Is_Bus (Bus) then
                     return Bus;
                  elsif AINU.Is_Virtual_Bus (Bus) then
                     Bus := Parent_Component (Parent_Subcomponent (Bus));
                     if AINU.Is_Bus (Bus) then
                        return Bus;
                     end if;
                  end if;
               end if;

               S := AIN.Next_Node (S);
            end loop;
         end if;
      elsif AIN.Is_Out (Port) then
         L := Destinations (Port);
         if not AINU.Is_Empty (L) then
            S := AIN.First_Node (L);
            while Present (S) loop
               Connection := Extra_Item (S);

221
222
223
               if Present (Connection)
                 and then Get_Bound_Bus (Connection, False) /= No_Node
               then
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
                  Bus := Get_Bound_Bus (Connection, False);

                  if AINU.Is_Bus (Bus) then
                     return Bus;
                  elsif AINU.Is_Virtual_Bus (Bus) then
                     Bus := Parent_Component (Parent_Subcomponent (Bus));
                     if AINU.Is_Bus (Bus) then
                        return Bus;
                     end if;
                  end if;
               end if;

               S := AIN.Next_Node (S);
            end loop;
         end if;
      end if;

      return No_Node;

   end Get_Bus;

   -----------------
   -- Header_File --
   -----------------

   package body Header_File is

      procedure Visit_Architecture_Instance (E : Node_Id);
      procedure Visit_Component_Instance (E : Node_Id);
      procedure Visit_System_Instance (E : Node_Id);
      procedure Visit_Process_Instance
255
256
        (E                    : Node_Id;
         Real_Process         : Boolean := True;
257
258
259
260
261
262
         Associated_Component : Node_Id := No_Node);
      procedure Visit_Device_Instance (E : Node_Id);
      procedure Visit_Processor_Instance (E : Node_Id);
      procedure Visit_Virtual_Processor_Instance (E : Node_Id);
      procedure Visit_Thread_Instance (E : Node_Id);

263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
      System_Nb_Partitions    : Unsigned_Long_Long := 0;
      System_Nb_Threads       : Unsigned_Long_Long := 0;
      Process_Nb_Threads      : Unsigned_Long_Long := 0;
      Process_Nb_Buffers      : Unsigned_Long_Long := 0;
      Process_Nb_Events       : Unsigned_Long_Long := 0;
      Process_Nb_Lock_Objects : Unsigned_Long_Long := 0;
      System_Nb_Lock_Objects  : Unsigned_Long_Long := 0;
      Process_Nb_Blackboards  : Unsigned_Long_Long := 0;
      System_Nb_Ports         : Unsigned_Long_Long := 0;
      System_Stacks_Size      : Unsigned_Long_Long := 0;
      Partition_Stacks_Size   : Unsigned_Long_Long := 0;

      Kernel_Unit : Node_Id;

      Global_Nb_Ports_Node   : Node_Id;
      Kernel_Needs_Sched_Rms : Boolean;
      Kernel_Needs_Sched_Llf : Boolean;
      Kernel_Needs_Sched_Edf : Boolean;
      Kernel_Needs_Sched_Rr  : Boolean;

      System_Partitions_Ports : Node_Id;
284
285
286
287
288
      --  This is an array that contain all the partitions
      --  identifier for each port.
      --  Consequently, we have an array like that:
      --  pok_ports_partitions_id[POK_NB_PORTS] = {....}

289
      System_Partitions_Size : Node_Id;
290
291
292
293
      --  This array represents the size of each partition. We
      --  have an array like:
      --  POK_PARTTIONS_SIZE {xxx,xxx}

294
295
      System_Partitions_Scheduler       : Node_Id;
      System_Partitions_Nb_Threads      : Node_Id;
296
      System_Partitions_Nb_Lock_Objects : Node_Id;
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
      Major_Frame                       : Node_Id;
      System_Slots                      : Node_Id;
      System_Slots_Allocation           : Node_Id;
      System_Nb_Slots                   : Unsigned_Long_Long := 0;
      Local_Port_List                   : List_Id;
      Global_Port_List                  : List_Id;
      Node_List                         : List_Id;
      Local_Port_Identifier             : Unsigned_Long_Long := 0;
      Global_Port_Identifier            : Unsigned_Long_Long := 0;
      System_Use_Queueing_Ports         : Boolean;
      System_Use_Sampling_Ports         : Boolean;
      System_Use_Virtual_Ports          : Boolean;
      System_Partition_Identifier       : Unsigned_Long_Long := 0;
      Partition_Use_Error_Handling      : Boolean            := False;
      Kernel_Use_Error_Handling         : Boolean            := False;
      Kernel_Use_Pci                    : Boolean            := False;
      Kernel_Use_Io                     : Boolean            := False;
      Kernel_Use_Gettick                : Boolean            := False;
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339

      -----------
      -- Visit --
      -----------

      procedure Visit (E : Node_Id) is
      begin
         case Kind (E) is
            when K_Architecture_Instance =>
               Visit_Architecture_Instance (E);

            when K_Component_Instance =>
               Visit_Component_Instance (E);

            when others =>
               null;
         end case;
      end Visit;

      ---------------------------------
      -- Visit_Architecture_Instance --
      ---------------------------------

      procedure Visit_Architecture_Instance (E : Node_Id) is
      begin
340
341
342
         All_Ports        := AINU.New_List (AIN.K_List_Id, No_Location);
         Global_Port_List := New_List (CTN.K_Enumeration_Literals);
         Node_List        := New_List (CTN.K_Enumeration_Literals);
343
344
345
346
347
348
349
350
351
352
353
354
355

         Array_Global_Ports_Nodes := CTU.Make_Array_Values;

         Global_Nb_Ports_Node := Make_Literal (CV.New_Int_Value (0, 1, 10));

         Visit (Root_System (E));
      end Visit_Architecture_Instance;

      ------------------------------
      -- Visit_Component_Instance --
      ------------------------------

      procedure Visit_Component_Instance (E : Node_Id) is
356
357
         Category : constant Component_Category :=
           AIE.Get_Category_Of_Component (E);
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
      begin
         case Category is
            when CC_System =>
               Visit_System_Instance (E);

            when CC_Process =>
               Visit_Process_Instance (E);

            when CC_Processor =>
               Visit_Processor_Instance (E);

            when CC_Device =>
               Visit_Device_Instance (E);

            when CC_Virtual_Processor =>
               Visit_Virtual_Processor_Instance (E);

            when CC_Thread =>
               Visit_Thread_Instance (E);

            when others =>
               null;
         end case;
      end Visit_Component_Instance;

      --------------------------------------
      -- Visit_Virtual_Processor_Instance --
      --------------------------------------

      procedure Visit_Virtual_Processor_Instance (E : Node_Id) is
388
389
390
         N         : Node_Id;
         S         : Node_Id;
         U         : Node_Id;
391
392
         Processes : List_Id;
      begin
393
         if POK_Flavor = ARINC653 then
394
            CTU.Append_Node_To_List
395
              (RE (RE_Pok_Sched_Rr),
396
397
               CTN.Values (System_Partitions_Scheduler));
            Kernel_Needs_Sched_Rr := True;
398
         elsif POK_Flavor = POK then
399
400
401
            if Get_POK_Scheduler (E) = RR then
               Kernel_Needs_Sched_Rr := True;
               CTU.Append_Node_To_List
402
                 (RE (RE_Pok_Sched_Rr),
403
404
405
406
                  CTN.Values (System_Partitions_Scheduler));
            elsif Get_POK_Scheduler (E) = RMS then
               Kernel_Needs_Sched_Rms := True;
               CTU.Append_Node_To_List
407
                 (RE (RE_Pok_Sched_Rms),
408
409
410
411
                  CTN.Values (System_Partitions_Scheduler));
            elsif Get_POK_Scheduler (E) = EDF then
               Kernel_Needs_Sched_Edf := True;
               CTU.Append_Node_To_List
412
                 (RE (RE_Pok_Sched_Edf),
413
414
415
416
                  CTN.Values (System_Partitions_Scheduler));
            elsif Get_POK_Scheduler (E) = LLF then
               Kernel_Needs_Sched_Llf := True;
               CTU.Append_Node_To_List
417
                 (RE (RE_Pok_Sched_Llf),
418
419
420
                  CTN.Values (System_Partitions_Scheduler));
            else
               Display_Error
421
                 ("POK does not support a such scheduler in partitions",
422
423
424
425
                  Fatal => True);
            end if;
         end if;

426
427
428
         N :=
           CTU.Make_Literal
             (CV.New_Int_Value (System_Partition_Identifier, 1, 10));
429
430
         Set_Handling (E, By_Node, H_C_Deployment_Spec, N);

431
432
433
         N :=
           CTU.Make_Literal
             (CV.New_Int_Value (System_Partition_Identifier, 1, 10));
434
435
436
437
438

         CTN.Set_Deployment_Node (Backend_Node (Identifier (E)), N);

         if Present (Backend_Node (Identifier (E))) then
            Processes := CTN.Processes (Backend_Node (Identifier (E)));
439
            S         := AIN.First_Node (Processes);
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
            while Present (S) loop
               U := Current_Entity;
               Pop_Entity;
               Visit (AIN.Item (S));
               Push_Entity (U);
               S := AIN.Next_Node (S);
            end loop;
         end if;

         System_Partition_Identifier := System_Partition_Identifier + 1;
      end Visit_Virtual_Processor_Instance;

      ------------------------------
      -- Visit_Processor_Instance --
      ------------------------------

      procedure Visit_Processor_Instance (E : Node_Id) is
         N : Node_Id;
         S : Node_Id;
         K : Node_Id;
         L : List_Id;
         U : Node_Id;
         P : Node_Id;
         A : Node_Id;
      begin
         U := CTN.Naming_Node (Backend_Node (Identifier (E)));
         A := CTN.Deployment_Node (Backend_Node (Identifier (E)));
         P := CTN.Entity (U);

         Push_Entity (C_Root);
         Push_Entity (A);

         Kernel_Unit := U;

         Start_Recording_Handlings;

         Used_Buses := AINU.New_List (AIN.K_List_Id, No_Location);

478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
         System_Partition_Identifier := 0;
         System_Stacks_Size          := 0;
         System_Nb_Threads           := 0;
         System_Nb_Partitions        := 0;
         System_Nb_Slots             := 0;
         System_Nb_Ports             := 0;
         System_Nb_Lock_Objects      := 0;
         Kernel_Use_Pci              := False;
         Kernel_Use_Io               := False;
         Kernel_Use_Gettick          := False;

         Kernel_Needs_Sched_Rms := False;
         Kernel_Needs_Sched_Edf := False;
         Kernel_Needs_Sched_Llf := False;
         Kernel_Needs_Sched_Rr  := False;

         Local_Port_List       := New_List (CTN.K_Enumeration_Literals);
         Local_Port_Identifier := 0;

         System_Partitions_Ports           := CTU.Make_Array_Values;
         System_Partitions_Size            := CTU.Make_Array_Values;
         System_Partitions_Scheduler       := CTU.Make_Array_Values;
         System_Partitions_Nb_Threads      := CTU.Make_Array_Values;
         System_Partitions_Nb_Lock_Objects := CTU.Make_Array_Values;
         System_Slots                      := CTU.Make_Array_Values;
         System_Slots_Allocation           := CTU.Make_Array_Values;
         System_Use_Queueing_Ports         := False;
         System_Use_Virtual_Ports          := False;
         System_Use_Sampling_Ports         := False;
         Major_Frame                       := No_Node;
         Kernel_Use_Error_Handling         := False;
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523

         Pop_Entity;
         Push_Entity (P);
         Push_Entity (U);

         CTU.Set_Deployment_Header;

         if not AINU.Is_Empty (Subcomponents (E)) then
            S := First_Node (Subcomponents (E));
            while Present (S) loop
               Visit (Corresponding_Instance (S));
               S := Next_Node (S);
            end loop;
         end if;

524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
         --
         --  If we are using DEOS, we do not need
         --  to write code to configure the kernel, this
         --  is done through the XML file of the deos_conf
         --  backend.
         --

         if POK_Flavor = DEOS then
            Reset_Handlings;

            Pop_Entity;
            Pop_Entity;
            Pop_Entity;
            return;
         end if;

540
541
         Runtime.Kernel_Mode;

542
543
544
545
546
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Local_Node),
              Value               =>
                CTU.Make_Literal (CV.New_Int_Value (Node_Identifier, 1, 10)));
547

548
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
549
550
551
552

         --  Add the Local node identifier in the
         --  kernel/deployment.h file.

553
554
555
556
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Generated_Code),
              Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
557

558
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
559
560
561
562
563
564

         --  Define the maccro POK_GENERATED_CODE so that the runtime
         --  is aware that we use generated code. Consequently,
         --  the runtime can restrict included functions in the binary.
         --  Here, we do that at the kernel level.

565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
         N :=
           Message_Comment
             ("The POK_LOCAL_NODE macro corresponds to the identifier " &
              "for this node in the distributed system. This identifier " &
              "is unique for each node" &
              "In this case, this identifier was deduced from the" &
              Get_Name_String
                (Display_Name (Identifier (Parent_Subcomponent (E)))) &
              " processor component.");
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         N :=
           Make_Expression
             (CTU.Make_Defining_Identifier (Map_Node_Name (E)),
              Op_Equal,
              (Make_Literal (CV.New_Int_Value (Node_Identifier, 0, 10))));
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
         Append_Node_To_List (N, Node_List);

         Node_Identifier := Node_Identifier + 1;

         if Get_POK_Major_Frame (E) /= Null_Time then
            Major_Frame := Map_Time_To_Millisecond (Get_POK_Major_Frame (E));
         end if;

         if Get_POK_Slots (E) /= Empty_Time_Array then
            declare
               T : constant Time_Array := Get_POK_Slots (E);
            begin
               for I in T'Range loop
                  N := Map_Time_To_Millisecond (T (I));
                  CTU.Append_Node_To_List (N, CTN.Values (System_Slots));
                  System_Nb_Slots := System_Nb_Slots + 1;
               end loop;
            end;
         else
            Display_Error
601
602
              ("You must define partitions time slots",
               Fatal => True);
603
604
605
606
         end if;

         if POK_Flavor = POK and then Get_POK_Scheduler (E) /= Static then
            Display_Error
607
608
              ("POK systems must have a static scheduler",
               Fatal => True);
609
610
611
612
613
614
615
616
617
618
619
620
         end if;

         L := Get_POK_Slots_Allocation (E);
         if L /= No_List then
            S := ATN.First_Node (L);
            while Present (S) loop
               K := ATE.Get_Referenced_Entity (S);

               N := Get_Handling (K, By_Node, H_C_Deployment_Spec);

               if Present (N) then
                  CTU.Append_Node_To_List
621
622
                    (CTU.Copy_Node (N),
                     CTN.Values (System_Slots_Allocation));
623
624
               else
                  CTU.Append_Node_To_List
625
626
                    (Make_Literal (CV.New_Int_Value (0, 1, 10)),
                     CTN.Values (System_Slots_Allocation));
627
628
629
630
631
632
633
               end if;

               S := ATN.Next_Node (S);

            end loop;
         else
            Display_Error
634
              ("You must define partitions time slots allocation",
635
636
637
638
               Fatal => True);
         end if;

         if Kernel_Use_Error_Handling then
639
640
641
642
643
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Error_Handling),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
644
645
646
         end if;

         if Kernel_Use_Pci then
647
648
649
650
651
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Pci),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
652
653
654
         end if;

         if Kernel_Use_Io then
655
656
657
658
659
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Io),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
660
661
662
         end if;

         if Kernel_Use_Gettick then
663
664
665
666
667
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Gettick),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
668
669
670
         end if;

         if System_Nb_Threads > 0 then
671
672
673
674
675
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Threads),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
676
677
678
         end if;

         if System_Nb_Partitions > 0 then
679
680
681
682
683
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Partitions),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
684

685
686
687
688
689
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Sched),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
         end if;

--         N := CTU.Make_Define_Statement
--               (Defining_Identifier => RE (RE_Pok_Needs_Debug),
--                  Value => CTU.Make_Literal
--                     (CV.New_Int_Value (1, 1, 10)));
--         CTU.Append_Node_To_List
--                  (N, CTN.Declarations (CTU.Current_File));

--         N := Message_Comment
--            ("The maccro POK_NEEDS_DEBUG "&
--             "activates debug in the kernel (not in libpok).");

--         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

--  Try to remove the debug mode, automatically added previously.

707
         N := Message_Comment ("#define POK_NEEDS_DEBUG 1");
708
709
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

710
711
712
         N :=
           Message_Comment
             ("If you want to activate DEBUG mode, uncomment previous line");
713
714
715
716
717
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         --  Define useful constants that configures the kernel : partition
         --  names, sizes and so on.

718
719
720
721
722
723
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Nb_Partitions),
              Value               =>
                CTU.Make_Literal
                  (CV.New_Int_Value (System_Nb_Partitions, 1, 10)));
724
725
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

726
727
728
729
730
731
         N :=
           Message_Comment
             ("The maccro POK_CONFIG_NB_PARTITIONS " &
              "indicates the amount of partitions in the current system." &
              "It corresponds to the amount of process components" &
              "in the system.");
732
733
734
735
736
737
738
739
740
741
742

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         System_Nb_Threads := System_Nb_Threads + System_Nb_Partitions;

         --  We add one thread per partitions

         System_Nb_Threads := System_Nb_Threads + 2;

         --  We add the kernel and idle threads

743
744
745
746
747
748
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Nb_Threads),
              Value               =>
                CTU.Make_Literal
                  (CV.New_Int_Value (System_Nb_Threads, 1, 10)));
749
750
751

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

752
753
754
755
756
757
         N :=
           Message_Comment
             ("The maccro POK_CONFIG_NB_THREADS " &
              "indicates the amount of threads used in the kernel." &
              "It comprises the tasks for the partition and the main " &
              "task of each partition that initialize all ressources.");
758
759
760

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

761
762
763
764
765
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Partitions_Nthreads),
              Value               => System_Partitions_Nb_Threads);
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
766

767
768
769
770
771
772
         N :=
           Message_Comment
             ("The maccro POK_CONFIG_NB_PARTITIONS_NTHREADS " &
              "indicates the amount of threads in each partition " &
              "we also add an additional process that initialize " &
              "all partition's entities (communication, threads, ...)");
773
774
775
776
777
778

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         --  Declare only used schedulers

         if Kernel_Needs_Sched_Rms then
779
780
781
782
783
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Sched_Rms),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
784
785
786
         end if;

         if Kernel_Needs_Sched_Rr then
787
788
789
790
791
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Sched_Rr),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
792
793
794
         end if;

         if Kernel_Needs_Sched_Llf then
795
796
797
798
799
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Sched_Llf),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
800
801
802
         end if;

         if Kernel_Needs_Sched_Edf then
803
804
805
806
807
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Sched_Edf),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
808
809
810
         end if;

         if System_Nb_Lock_Objects > 0 then
811
812
813
814
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Lockobjects),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
815

816
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
817

818
819
820
821
822
823
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Lockobjects),
                 Value               =>
                   CTU.Make_Literal
                     (CV.New_Int_Value (System_Nb_Lock_Objects, 1, 10)));
824

825
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
826

827
828
829
830
831
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier =>
                   RE (RE_Pok_Config_Partitions_Nlockobjects),
                 Value => System_Partitions_Nb_Lock_Objects);
832

833
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
834

835
836
837
838
            N :=
              Message_Comment
                ("The maccro POK_CONFIG_NB_PARTITIONS_NLOCKOBJECTS " &
                 "indicates the amount of lockobjects in each partition ");
839

840
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
841
842
         end if;

843
844
845
846
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Partitions_Size),
              Value               => System_Partitions_Size);
847
848
849

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

850
851
852
853
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Partitions_Scheduler),
              Value               => System_Partitions_Scheduler);
854
855
856

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

857
858
859
860
861
862
         N :=
           Message_Comment
             ("The maccro POK_CONFIG_PARTTITIONS_SIZE " &
              "indicates the required amount of memory for each partition." &
              "This value was deduced from the property " &
              "POK::Needed_Memory_Size of each process");
863
864
865
866

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         if not CTU.Is_Empty (CTN.Values (System_Slots)) then
867
868
869
870
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Scheduling_Slots),
                 Value               => System_Slots);
871

872
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
873
874
875
         end if;

         if not CTU.Is_Empty (CTN.Values (System_Slots_Allocation)) then
876
877
878
879
880
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier =>
                   RE (RE_Pok_Config_Scheduling_Slots_Allocation),
                 Value => System_Slots_Allocation);
881

882
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
883
884
         end if;

885
886
887
888
889
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Scheduling_Nbslots),
              Value               =>
                CTU.Make_Literal (CV.New_Int_Value (System_Nb_Slots, 1, 10)));
890

891
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
892
893

         if Major_Frame /= No_Node then
894
895
896
897
898
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier =>
                   RE (RE_Pok_Config_Scheduling_Major_Frame),
                 Value => Major_Frame);
899

900
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
901
902
903
         end if;

         if System_Use_Sampling_Ports then
904
905
906
907
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Ports_Sampling),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
908

909
910
911
912
913
914
915
916
917
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
            N :=
              Message_Comment
                ("The maccro POK_NEEDS_PORTS_SAMPLING indicates " &
                 "that we need sampling ports facilities in POK." &
                 "It also means that we have intra-partition " &
                 "communication between several processes through " &
                 "event data port.");
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
918
919
920
         end if;

         if System_Use_Queueing_Ports then
921
922
923
924
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Ports_Queueing),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
925

926
927
928
929
930
931
932
933
934
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
            N :=
              Message_Comment
                ("The maccro POK_NEEDS_PORTS_QUEUEING indicates " &
                 "that we need queueing ports facilities in POK." &
                 "It also means that we have inter-partition " &
                 "communication between several processes through " &
                 "event data port.");
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
935
936
937
         end if;

         if System_Use_Virtual_Ports then
938
939
940
941
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Ports_Virtual),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
942

943
944
945
946
947
948
949
950
951
952
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
            N :=
              Message_Comment
                ("The maccro POK_NEEDS_PORTS_VIRTUAL indicates " &
                 "that we need virtual ports facilities in POK." &
                 "It also means that we have inter-partition " &
                 "communication between several processes through " &
                 "[event] data port. Virtual ports are uses " &
                 "for device drivers interfacing");
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
953
954
         end if;

955
956
957
958
959
960
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Stacks_Size),
              Value               =>
                CTU.Make_Literal
                  (CV.New_Int_Value (System_Stacks_Size, 1, 10)));
961
962
963
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         if System_Nb_Ports > 0 then
964
965
966
967
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Partitions_Ports),
                 Value               => System_Partitions_Ports);
968

969
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
970

971
972
973
974
975
976
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Ports),
                 Value               =>
                   CTU.Make_Literal
                     (CV.New_Int_Value (System_Nb_Ports, 1, 10)));
977

978
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
979

980
981
982
983
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Global_Ports),
                 Value               => Global_Nb_Ports_Node);
984

985
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
986

987
988
989
990
991
992
            N :=
              Message_Comment
                ("The maccro POK_CONFIG_NB_PORTS represent the amount " &
                 "of inter-partition communication in the system." &
                 "Sampling and Queueing ports are counted.");
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
993
994

            Set_Str_To_Name_Buffer ("invalid_local_port");
995
996
997
998
999
1000
            N :=
              Make_Expression
                (CTU.Make_Defining_Identifier (Name_Find),
                 Op_Equal,
                 (Make_Literal
                    (CV.New_Int_Value (Local_Port_Identifier, 0, 10))));
1001
1002
            Append_Node_To_List (N, Local_Port_List);

1003
1004
1005
1006
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Port_Local_Identifier_T),
                 Type_Definition     => Make_Enum_Aggregate (Local_Port_List));
1007
1008
            Append_Node_To_List (N, CTN.Declarations (Current_File));

1009
1010
1011
1012
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Node_Identifier_T),
                 Type_Definition     => Make_Enum_Aggregate (Node_List));
1013
1014
            Append_Node_To_List (N, CTN.Declarations (Current_File));

1015
1016
1017
1018
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Port_Identifier_T),
                 Type_Definition => Make_Enum_Aggregate (Global_Port_List));
1019
1020
            Append_Node_To_List (N, CTN.Declarations (Current_File));

1021
1022
1023
1024
1025
1026
            N :=
              Message_Comment
                ("This enumeration describes all ports on the current " &
                 "nodes. It is used by the configuration arrays in " &
                 "the generated file deployment.c.");
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1027
1028
1029
         end if;

         declare
1030
1031
1032
            Bus_Id   : Unsigned_Long_Long := 0;
            Bus_List : constant List_Id   :=
              New_List (CTN.K_Enumeration_Literals);
1033
1034
1035
1036
         begin
            S := AIN.First_Node (Used_Buses);

            while Present (S) loop
1037
1038
1039
1040
1041
               N :=
                 Make_Expression
                   (CTU.Make_Defining_Identifier (Map_Bus_Name (Item (S))),
                    Op_Equal,
                    (Make_Literal (CV.New_Int_Value (Bus_Id, 0, 10))));
1042
1043
1044
1045
1046
1047
1048
               Append_Node_To_List (N, Bus_List);

               Bus_Id := Bus_Id + 1;

               S := AIN.Next_Node (S);
            end loop;

1049
1050
1051
1052
1053
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Buses),
                 Value => CTU.Make_Literal (CV.New_Int_Value (Bus_Id, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1054

1055
1056
            N :=
              Make_Expression
1057
                (CTU.Make_Defining_Identifier
1058
1059
1060
                   (Get_String_Name ("invalid_bus")),
                 Op_Equal,
                 (Make_Literal (CV.New_Int_Value (Bus_Id, 0, 10))));
1061
1062
            Append_Node_To_List (N, Bus_List);

1063
1064
1065
1066
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Bus_Identifier_T),
                 Type_Definition     => Make_Enum_Aggregate (Bus_List));
1067
1068
1069
1070
1071
1072
            Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
         end;

         Reset_Handlings;

         CTN.Set_Value
1073
           (Global_Nb_Ports_Node,
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
            CV.New_Int_Value (Global_Port_Identifier, 1, 10));
         --  Update the value of the number of global ports,
         --  taking in accounts new procesed ports.

         Runtime.User_Mode;
         --  Fallback in user mode now, since we dont need
         --  functionnalities dedicated to kernelland.

         Pop_Entity;
         Pop_Entity;
         Pop_Entity;
      end Visit_Processor_Instance;

      ---------------------------
      -- Visit_System_Instance --
      ---------------------------

      procedure Visit_System_Instance (E : Node_Id) is
         S                  : Node_Id;
         Component_Instance : Node_Id;
      begin
         if not AINU.Is_Empty (Subcomponents (E)) then
            S := First_Node (Subcomponents (E));
            while Present (S) loop
               Component_Instance := Corresponding_Instance (S);
               if AINU.Is_Processor (Component_Instance) then
                  Visit (Component_Instance);
               end if;
               S := Next_Node (S);
            end loop;
         end if;
      end Visit_System_Instance;

      ----------------------------
      -- Visit_Process_Instance --
      ----------------------------

      procedure Visit_Process_Instance
1112
1113
1114
1115
        (E                    : Node_Id;
         Real_Process         : Boolean := True;
         Associated_Component : Node_Id := No_Node)
      is
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
         C                       : Node_Id;
         N                       : Node_Id;
         O                       : Node_Id;
         F                       : Node_Id;
         U                       : Node_Id;
         P                       : Node_Id;
         Bound_Processor         : Node_Id;
         Communicating_Component : Node_Id;
         Property_Memory_Size    : Unsigned_Long_Long := 0;
         Bound_Memory_Component  : Node_Id;
         Bound_Memory_Size       : Unsigned_Long_Long := 0;
         Used_Memory_Size        : Unsigned_Long_Long := 0;
         Additional_Features     : List_Id;
      begin
         if Real_Process then
1131
1132
1133
            U :=
              CTN.Distributed_Application_Unit
                (CTN.Naming_Node (Backend_Node (Identifier (E))));
1134
1135
1136
1137
1138
1139
            P := CTN.Entity (U);
            CTU.Push_Entity (P);
            CTU.Push_Entity (U);
            Communicating_Component := E;
         else
            Communicating_Component := Associated_Component;
1140
1141
1142
1143
            U                       :=
              CTN.Distributed_Application_Unit
                (CTN.Naming_Node
                   (Backend_Node (Identifier (Communicating_Component))));
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
            P := CTN.Entity (U);
         end if;

         CTU.Set_Deployment_Header;

         Partition_Stacks_Size := 0;

         if Real_Process then
            Bound_Processor := Get_Bound_Processor (E);
         else
1154
            Bound_Processor := Get_Bound_Processor (Associated_Component);
1155
1156
         end if;

1157
1158
1159
1160
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Generated_Code),
              Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
1161

1162
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1163
1164
1165
1166
1167
1168
1169

         --  Define the maccro POK_GENERATED_CODE so that the runtime
         --  is aware that we use generated code. Consequently,
         --  the runtime can restrict included functions in the binary.
         --  Here, we do that at the partition level.

         if Is_Defined_Property
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
             (Bound_Processor,
              "pok::additional_features")
         then
            Additional_Features :=
              ATN.Multi_Value
                (AIN.Property_Association_Value
                   (AIEP.Find_Property_Association_From_Name
                      (Property_List => AIN.Properties (Bound_Processor),
                       Property_Name =>
                         Get_String_Name ("pok::additional_features"),
                       In_Mode => No_Name)));
1181
1182
1183

            if not ATNU.Is_Empty (Additional_Features) then
               declare
1184
                  S        : Node_Id;
1185
1186
1187
1188
                  Tmp_Name : Name_Id;
               begin
                  S := ATN.First_Node (Additional_Features);
                  while Present (S) loop
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
                     Set_Str_To_Name_Buffer ("pok_needs_");
                     Get_Name_String_And_Append
                       (ATN.Name (ATN.Identifier (S)));

                     Tmp_Name := To_Upper (Name_Find);

                     N :=
                       CTU.Make_Define_Statement
                         (Defining_Identifier =>
                            Make_Defining_Identifier
                              (Tmp_Name,
                               C_Conversion => False),
                          Value =>
                            CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
                     CTU.Append_Node_To_List
                       (N,
                        CTN.Declarations (CTU.Current_File));

                     if Get_Name_String (ATN.Name (ATN.Identifier (S))) =
                       "console"
                     then
                        CTU.Pop_Entity;
                        CTU.Pop_Entity;

                        Push_Entity (Kernel_Unit);
                        Set_Deployment_Header;

                        N :=
                          CTU.Make_Define_Statement
                            (Defining_Identifier => RE (RE_Pok_Needs_Console),
                             Value               =>
                               CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
1221
                        CTU.Append_Node_To_List
1222
1223
                          (N,
                           CTN.Declarations (CTU.Current_File));
1224

1225
                        Pop_Entity;
1226

1227
1228
                        CTU.Push_Entity (P);
                        CTU.Push_Entity (U);
1229

1230
1231
                        Set_Deployment_Header;
                     end if;
1232

1233
1234
1235
1236
1237
                     if Get_Name_String (ATN.Name (ATN.Identifier (S))) =
                       "x86_vmm"
                     then
                        CTU.Pop_Entity;
                        CTU.Pop_Entity;
1238

1239
1240
                        Push_Entity (Kernel_Unit);
                        Set_Deployment_Header;
1241

1242
1243
1244
1245
1246
1247
1248
1249
                        N :=
                          CTU.Make_Define_Statement
                            (Defining_Identifier => RE (RE_Pok_Needs_X86_Vmm),
                             Value               =>
                               CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
                        CTU.Append_Node_To_List
                          (N,
                           CTN.Declarations (CTU.Current_File));
1250

1251
                        Pop_Entity;
1252

1253
1254
                        CTU.Push_Entity (P);
                        CTU.Push_Entity (U);
1255

1256
1257
                        Set_Deployment_Header;
                     end if;
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287

                     S := ATN.Next_Node (S);
                  end loop;
               end;
            end if;
         end if;

         Partition_Use_Error_Handling := False;

         Process_Nb_Threads      := 0;
         Process_Nb_Buffers      := 0;
         Process_Nb_Events       := 0;
         Process_Nb_Lock_Objects := 0;
         Process_Nb_Blackboards  := 0;
         System_Nb_Partitions    := System_Nb_Partitions + 1;

         --  The Needed_Memory_Size is required, it must be
         --  declared in the model. It defines the allocated
         --  size for each partition.

         Property_Memory_Size := Get_Needed_Memory_Size (E);

         if Real_Process then
            Bound_Memory_Component := Get_Bound_Memory (E);
         else
            Bound_Memory_Component := Get_Bound_Memory (Associated_Component);
         end if;

         if Bound_Memory_Component /= No_Node then
            declare
1288
               Byte_Count : Unsigned_Long_Long := 1;
1289
1290
               Word_Size  : Unsigned_Long_Long := 1;
            begin
1291
1292
               if Get_Byte_Count (Bound_Memory_Component) /= 0 then
                  Byte_Count := Get_Byte_Count (Bound_Memory_Component);
1293
1294
1295
               end if;

               if Get_Word_Size (Bound_Memory_Component) /= Null_Size then
1296
1297
                  Word_Size :=
                    To_Bytes (Get_Word_Size (Bound_Memory_Component));
1298
               end if;
1299
               Bound_Memory_Size := Byte_Count * Word_Size;
1300
1301
1302

               --  byte_count override other properties.
               if Is_Defined_Property
1303
1304
1305
                   (Bound_Memory_Component,
                    "byte_count")
               then
1306
                  Bound_Memory_Size :=
1307
1308
1309
                    Get_Integer_Property
                      (Bound_Memory_Component,
                       "byte_count");
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
               end if;
            end;
         end if;

         if Bound_Memory_Size /= 0 then
            Used_Memory_Size := Bound_Memory_Size;
         elsif Property_Memory_Size /= 0 then
            Used_Memory_Size := Property_Memory_Size;
         else
            Display_Located_Error
1320
1321
1322
              (Loc (E),
               "You must provide the size of the parttion",
               Fatal => True);
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
         end if;

         if Real_Process then
            Communicating_Component := E;
         else
            Communicating_Component := Associated_Component;
         end if;

         if not AINU.Is_Empty (Features (Communicating_Component)) then
            F := First_Node (Features (Communicating_Component));

            while Present (F) loop
1335
1336
1337
               if Kind (F) = K_Port_Spec_Instance
                 and then Get_Connection_Pattern (F) = Inter_Process
               then
1338
1339

                  if Is_Defined_Property
1340
1341
1342
1343
1344
1345
1346
1347
                      (F,
                       "allowed_connection_binding_class")
                  then
                     N :=
                       CTU.Make_Define_Statement
                         (Defining_Identifier => RE (RE_Pok_Needs_Protocols),
                          Value               =>
                            CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
1348
                     CTU.Append_Node_To_List
1349
1350
1351
1352
1353
1354
1355
1356
                       (N,
                        CTN.Declarations (CTU.Current_File));

                     N :=
                       CTU.Make_Define_Statement
                         (Defining_Identifier => RE (RE_Pok_Needs_Libc_String),
                          Value               =>
                            CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
1357
                     CTU.Append_Node_To_List
1358
1359
                       (N,
                        CTN.Declarations (CTU.Current_File));
1360
1361
1362
1363
1364
1365
1366
1367
1368

                     Handle_Virtual_Buses_Properties (F);

                     Set_Activity_Source;
                     Add_Include (RH (RH_Protocols));
                     Set_Deployment_Header;
                  end if;

                  AINU.Append_Node_To_List
1369
1370
                    (AINU.Make_Node_Container (F),
                     All_Ports);
1371
1372
1373

                  Handle_Buses_Connections (F);

1374
1375
1376
1377
1378
1379
                  N :=
                    Make_Expression
                      (CTU.Make_Defining_Identifier (Map_Port_Name (F)),
                       Op_Equal,
                       (Make_Literal
                          (CV.New_Int_Value (Local_Port_Identifier, 0, 10))));
1380
1381
                  Append_Node_To_List (N, Local_Port_List);

1382
1383
1384
1385
1386
1387
                  N :=
                    Make_Expression
                      (CTU.Make_Defining_Identifier (Map_Port_Name (F, True)),
                       Op_Equal,
                       (Make_Literal
                          (CV.New_Int_Value (Global_Port_Identifier, 0, 10))));
1388
1389
1390
                  Append_Node_To_List (N, Global_Port_List);

                  CTU.Append_Node_To_List
1391
1392
1393
1394
1395
                    (CTU.Copy_Node
                       (Get_Handling
                          (Bound_Processor,
                           By_Node,
                           H_C_Deployment_Spec)),
1396
1397
1398
                     CTN.Values (System_Partitions_Ports));
                  --  Declare which partition would use this port.

1399
                  Local_Port_Identifier  := Local_Port_Identifier + 1;
1400
1401
1402
                  Global_Port_Identifier := Global_Port_Identifier + 1;

                  CTU.Append_Node_To_List
1403
                    (Make_Literal (CV.New_Int_Value (Node_Identifier, 0, 10)),
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
                     CTN.Values (Array_Global_Ports_Nodes));

                  if not AIN.Is_Event (F) and then AIN.Is_Data (F) then
                     System_Use_Sampling_Ports := True;
                  elsif AIN.Is_Data (F) and then AIN.Is_Event (F) then
                     System_Use_Queueing_Ports := True;
                  end if;

                  System_Nb_Ports := System_Nb_Ports + 1;
               end if;
               F := Next_Node (F);
            end loop;
         end if;

         --  Handle subcomponents.

         if not AINU.Is_Empty (Subcomponents (E)) then
            C := First_Node (Subcomponents (E));

            while Present (C) loop
               --  If we have a protected data, we create semaphore variables.
1425
1426
1427
               if AINU.Is_Data (Corresponding_Instance (C))
                 and then Is_Protected_Data (Corresponding_Instance (C))
               then
1428
1429
1430
1431
1432
1433

                  --  If we have a protected shared data, we declare
                  --  a new semaphore in the kernel and in the current
                  --  partitions. This dimension resources of kernel
                  --  and partition.

1434
                  System_Nb_Lock_Objects  := System_Nb_Lock_Objects + 1;
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
                  Process_Nb_Lock_Objects := Process_Nb_Lock_Objects + 1;
               else
                  Visit (Corresponding_Instance (C));
               end if;
               C := Next_Node (C);
            end loop;
         end if;
         --  Append the partition name and its size to a global

         --  array that will configure the kernel

1446
         O := CTU.Make_Literal (CV.New_Int_Value (Used_Memory_Size, 1, 10));
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459

         CTU.Append_Node_To_List (O, CTN.Values (System_Partitions_Size));

         if Partition_Use_Error_Handling then
            Process_Nb_Threads := Process_Nb_Threads + 1;
            System_Nb_Threads  := System_Nb_Threads + 1;
            --  If we have error handling in this partition, we need
            --  to add one thread in the partitions so we declare
            --  an additional thread in the partition and in the kernel.
         end if;

         Process_Nb_Threads := Process_Nb_Threads + 1;

1460
1461
1462
         CTU.Append_Node_To_List
           (CTU.Make_Literal (CV.New_Int_Value (Process_Nb_Threads, 1, 10)),
            CTN.Values (System_Partitions_Nb_Threads));
1463

1464
1465
1466
1467
         CTU.Append_Node_To_List
           (CTU.Make_Literal
              (CV.New_Int_Value (Process_Nb_Lock_Objects, 1, 10)),
            CTN.Values (System_Partitions_Nb_Lock_Objects));
1468
1469
1470

         --  Finally, declare the amount of threads inside the partition

1471
1472
1473
1474
1475
1476
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Nb_Threads),
              Value               =>
                CTU.Make_Literal
                  (CV.New_Int_Value (Process_Nb_Threads, 1, 10)));
1477
1478
1479
1480

         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         if Process_Nb_Buffers > 0 then
1481
1482
1483
1484
1485
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Buffers),
                 Value               =>
                   CTU.Make_Literal
1486
1487
1488
                     (CV.New_Int_Value (Process_Nb_Buffers, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

1489
1490
1491
1492
1493
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Buffers),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1494
1495
1496
         end if;

         if Process_Nb_Events > 0 then
1497
1498
1499
1500
1501
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Events),
                 Value               =>
                   CTU.Make_Literal
1502
1503
1504
                     (CV.New_Int_Value (Process_Nb_Events, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

1505
1506
1507
1508
1509
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Events),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1510
1511
1512
1513
1514
1515
         end if;

         --  Define NB_BLACKBOARDS or NB_BUFFERS directive in the deployment.h
         --  of each partition.

         if Process_Nb_Blackboards > 0 then
1516
1517
1518
1519
1520
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Blackboards),
                 Value               =>
                   CTU.Make_Literal
1521
1522
1523
                     (CV.New_Int_Value (Process_Nb_Blackboards, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

1524
1525
1526
1527
1528
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Blackboards),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1529
1530
1531
1532
1533
         end if;

         --  Define POK_NEEDS_MIDDLEWARE in each partition

         if Process_Nb_Blackboards > 0 or else Process_Nb_Buffers > 0 then
1534
1535
1536
1537
1538
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Middleware),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1539
1540
         end if;

1541
1542
1543
1544
1545
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Stacks_Size),
              Value               =>
                CTU.Make_Literal
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
                  (CV.New_Int_Value (Partition_Stacks_Size, 1, 10)));
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         if Real_Process then
            CTU.Pop_Entity;
            CTU.Pop_Entity;
         end if;
      end Visit_Process_Instance;

      ---------------------------
      -- Visit_Device_Instance --
      ---------------------------

      procedure Visit_Device_Instance (E : Node_Id) is
         N : Node_Id;
         F : Node_Id;
         S : Node_Id;
1563
1564
1565
1566
         U : constant Node_Id :=
           CTN.Distributed_Application_Unit
             (CTN.Naming_Node (Backend_Node (Identifier (E))));
         P              : constant Node_Id := CTN.Entity (U);
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
         Implementation : Node_Id;
      begin
         CTU.Push_Entity (P);
         CTU.Push_Entity (U);

         CTU.Set_Deployment_Header;

         Current_Device := E;

         if Is_Defined_Property (E, "pok::hw_addr") then
1577
1578
1579
1580
1581
1582
1583
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Hw_Addr),
                 Value               =>
                   CTU.Make_Literal
                     (CV.New_Pointed_Char_Value
                        (Get_String_Property (E, "pok::hw_addr"))));
1584
1585
1586
1587
1588

            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
         end if;

         if Is_Defined_Property (E, "pok::pci_device_id") then