ocarina-backends-pok_c-deployment.adb 129 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
Julien's avatar
Julien committed
393
         if POK_Flavor = ARINC653 or else POK_Flavor = DEOS then
394
            CTU.Append_Node_To_List
395
              (RE (RE_Pok_Sched_Rr),
396
397
398
399
400
401
               CTN.Values (System_Partitions_Scheduler));
            Kernel_Needs_Sched_Rr := True;
         else
            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
524
525

         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;

         Runtime.Kernel_Mode;

526
527
528
529
530
         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)));
531

532
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
533
534
535
536

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

537
538
539
540
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Generated_Code),
              Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
541

542
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
543
544
545
546
547
548

         --  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.

549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
         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))));
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
         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
585
586
              ("You must define partitions time slots",
               Fatal => True);
587
588
589
590
         end if;

         if POK_Flavor = POK and then Get_POK_Scheduler (E) /= Static then
            Display_Error
591
592
              ("POK systems must have a static scheduler",
               Fatal => True);
593
594
595
596
597
598
599
600
601
602
603
604
         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
605
606
                    (CTU.Copy_Node (N),
                     CTN.Values (System_Slots_Allocation));
607
608
               else
                  CTU.Append_Node_To_List
609
610
                    (Make_Literal (CV.New_Int_Value (0, 1, 10)),
                     CTN.Values (System_Slots_Allocation));
611
612
613
614
615
616
617
               end if;

               S := ATN.Next_Node (S);

            end loop;
         else
            Display_Error
618
              ("You must define partitions time slots allocation",
619
620
621
622
               Fatal => True);
         end if;

         if Kernel_Use_Error_Handling then
623
624
625
626
627
            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));
628
629
630
         end if;

         if Kernel_Use_Pci then
631
632
633
634
635
            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));
636
637
638
         end if;

         if Kernel_Use_Io then
639
640
641
642
643
            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));
644
645
646
         end if;

         if Kernel_Use_Gettick then
647
648
649
650
651
            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));
652
653
654
         end if;

         if System_Nb_Threads > 0 then
655
656
657
658
659
            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));
660
661
662
         end if;

         if System_Nb_Partitions > 0 then
663
664
665
666
667
            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));
668

669
670
671
672
673
            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));
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
         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.

691
         N := Message_Comment ("#define POK_NEEDS_DEBUG 1");
692
693
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

694
695
696
         N :=
           Message_Comment
             ("If you want to activate DEBUG mode, uncomment previous line");
697
698
699
700
701
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

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

702
703
704
705
706
707
         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)));
708
709
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

710
711
712
713
714
715
         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.");
716
717
718
719
720
721
722
723
724
725
726

         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

727
728
729
730
731
732
         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)));
733
734
735

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

736
737
738
739
740
741
         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.");
742
743
744

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

745
746
747
748
749
         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));
750

751
752
753
754
755
756
         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, ...)");
757
758
759
760
761
762

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

         --  Declare only used schedulers

         if Kernel_Needs_Sched_Rms then
763
764
765
766
767
            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));
768
769
770
         end if;

         if Kernel_Needs_Sched_Rr then
771
772
773
774
775
            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));
776
777
778
         end if;

         if Kernel_Needs_Sched_Llf then
779
780
781
782
783
            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));
784
785
786
         end if;

         if Kernel_Needs_Sched_Edf then
787
788
789
790
791
            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));
792
793
794
         end if;

         if System_Nb_Lock_Objects > 0 then
795
796
797
798
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Lockobjects),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
799

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

802
803
804
805
806
807
            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)));
808

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

811
812
813
814
815
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier =>
                   RE (RE_Pok_Config_Partitions_Nlockobjects),
                 Value => System_Partitions_Nb_Lock_Objects);
816

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

819
820
821
822
            N :=
              Message_Comment
                ("The maccro POK_CONFIG_NB_PARTITIONS_NLOCKOBJECTS " &
                 "indicates the amount of lockobjects in each partition ");
823

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

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

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

834
835
836
837
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Partitions_Scheduler),
              Value               => System_Partitions_Scheduler);
838
839
840

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

841
842
843
844
845
846
         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");
847
848
849
850

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

         if not CTU.Is_Empty (CTN.Values (System_Slots)) then
851
852
853
854
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Scheduling_Slots),
                 Value               => System_Slots);
855

856
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
857
858
859
         end if;

         if not CTU.Is_Empty (CTN.Values (System_Slots_Allocation)) then
860
861
862
863
864
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier =>
                   RE (RE_Pok_Config_Scheduling_Slots_Allocation),
                 Value => System_Slots_Allocation);
865

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

869
870
871
872
873
         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)));
874

875
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
876
877

         if Major_Frame /= No_Node then
878
879
880
881
882
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier =>
                   RE (RE_Pok_Config_Scheduling_Major_Frame),
                 Value => Major_Frame);
883

884
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
885
886
887
         end if;

         if System_Use_Sampling_Ports then
888
889
890
891
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Needs_Ports_Sampling),
                 Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
892

893
894
895
896
897
898
899
900
901
            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));
902
903
904
         end if;

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

910
911
912
913
914
915
916
917
918
            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));
919
920
921
         end if;

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

927
928
929
930
931
932
933
934
935
936
            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));
937
938
         end if;

939
940
941
942
943
944
         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)));
945
946
947
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

         if System_Nb_Ports > 0 then
948
949
950
951
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Partitions_Ports),
                 Value               => System_Partitions_Ports);
952

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

955
956
957
958
959
960
            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)));
961

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

964
965
966
967
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Global_Ports),
                 Value               => Global_Nb_Ports_Node);
968

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

971
972
973
974
975
976
            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));
977
978

            Set_Str_To_Name_Buffer ("invalid_local_port");
979
980
981
982
983
984
            N :=
              Make_Expression
                (CTU.Make_Defining_Identifier (Name_Find),
                 Op_Equal,
                 (Make_Literal
                    (CV.New_Int_Value (Local_Port_Identifier, 0, 10))));
985
986
            Append_Node_To_List (N, Local_Port_List);

987
988
989
990
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Port_Local_Identifier_T),
                 Type_Definition     => Make_Enum_Aggregate (Local_Port_List));
991
992
            Append_Node_To_List (N, CTN.Declarations (Current_File));

993
994
995
996
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Node_Identifier_T),
                 Type_Definition     => Make_Enum_Aggregate (Node_List));
997
998
            Append_Node_To_List (N, CTN.Declarations (Current_File));

999
1000
1001
1002
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Port_Identifier_T),
                 Type_Definition => Make_Enum_Aggregate (Global_Port_List));
1003
1004
            Append_Node_To_List (N, CTN.Declarations (Current_File));

1005
1006
1007
1008
1009
1010
            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));
1011
1012
1013
         end if;

         declare
1014
1015
1016
            Bus_Id   : Unsigned_Long_Long := 0;
            Bus_List : constant List_Id   :=
              New_List (CTN.K_Enumeration_Literals);
1017
1018
1019
1020
         begin
            S := AIN.First_Node (Used_Buses);

            while Present (S) loop
1021
1022
1023
1024
1025
               N :=
                 Make_Expression
                   (CTU.Make_Defining_Identifier (Map_Bus_Name (Item (S))),
                    Op_Equal,
                    (Make_Literal (CV.New_Int_Value (Bus_Id, 0, 10))));
1026
1027
1028
1029
1030
1031
1032
               Append_Node_To_List (N, Bus_List);

               Bus_Id := Bus_Id + 1;

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

1033
1034
1035
1036
1037
            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));
1038

1039
1040
            N :=
              Make_Expression
1041
                (CTU.Make_Defining_Identifier
1042
1043
1044
                   (Get_String_Name ("invalid_bus")),
                 Op_Equal,
                 (Make_Literal (CV.New_Int_Value (Bus_Id, 0, 10))));
1045
1046
            Append_Node_To_List (N, Bus_List);

1047
1048
1049
1050
            N :=
              Make_Full_Type_Declaration
                (Defining_Identifier => RE (RE_Pok_Bus_Identifier_T),
                 Type_Definition     => Make_Enum_Aggregate (Bus_List));
1051
1052
1053
1054
1055
1056
            Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
         end;

         Reset_Handlings;

         CTN.Set_Value
1057
           (Global_Nb_Ports_Node,
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
            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
1096
1097
1098
1099
        (E                    : Node_Id;
         Real_Process         : Boolean := True;
         Associated_Component : Node_Id := No_Node)
      is
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
         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
1115
1116
1117
            U :=
              CTN.Distributed_Application_Unit
                (CTN.Naming_Node (Backend_Node (Identifier (E))));
1118
1119
1120
1121
1122
1123
            P := CTN.Entity (U);
            CTU.Push_Entity (P);
            CTU.Push_Entity (U);
            Communicating_Component := E;
         else
            Communicating_Component := Associated_Component;
1124
1125
1126
1127
            U                       :=
              CTN.Distributed_Application_Unit
                (CTN.Naming_Node
                   (Backend_Node (Identifier (Communicating_Component))));
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
            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
1138
            Bound_Processor := Get_Bound_Processor (Associated_Component);
1139
1140
         end if;

1141
1142
1143
1144
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Generated_Code),
              Value => CTU.Make_Literal (CV.New_Int_Value (1, 1, 10)));
1145

1146
         CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));
1147
1148
1149
1150
1151
1152
1153

         --  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
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
             (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)));
1165
1166
1167

            if not ATNU.Is_Empty (Additional_Features) then
               declare
1168
                  S        : Node_Id;
1169
1170
1171
1172
                  Tmp_Name : Name_Id;
               begin
                  S := ATN.First_Node (Additional_Features);
                  while Present (S) loop
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
                     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)));
1205
                        CTU.Append_Node_To_List
1206
1207
                          (N,
                           CTN.Declarations (CTU.Current_File));
1208

1209
                        Pop_Entity;
1210

1211
1212
                        CTU.Push_Entity (P);
                        CTU.Push_Entity (U);
1213

1214
1215
                        Set_Deployment_Header;
                     end if;
1216

1217
1218
1219
1220
1221
                     if Get_Name_String (ATN.Name (ATN.Identifier (S))) =
                       "x86_vmm"
                     then
                        CTU.Pop_Entity;
                        CTU.Pop_Entity;
1222

1223
1224
                        Push_Entity (Kernel_Unit);
                        Set_Deployment_Header;
1225

1226
1227
1228
1229
1230
1231
1232
1233
                        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));
1234

1235
                        Pop_Entity;
1236

1237
1238
                        CTU.Push_Entity (P);
                        CTU.Push_Entity (U);
1239

1240
1241
                        Set_Deployment_Header;
                     end if;
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271

                     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
1272
               Byte_Count : Unsigned_Long_Long := 1;
1273
1274
               Word_Size  : Unsigned_Long_Long := 1;
            begin
1275
1276
               if Get_Byte_Count (Bound_Memory_Component) /= 0 then
                  Byte_Count := Get_Byte_Count (Bound_Memory_Component);
1277
1278
1279
               end if;

               if Get_Word_Size (Bound_Memory_Component) /= Null_Size then
1280
1281
                  Word_Size :=
                    To_Bytes (Get_Word_Size (Bound_Memory_Component));
1282
               end if;
1283
               Bound_Memory_Size := Byte_Count * Word_Size;
1284
1285
1286

               --  byte_count override other properties.
               if Is_Defined_Property
1287
1288
1289
                   (Bound_Memory_Component,
                    "byte_count")
               then
1290
                  Bound_Memory_Size :=
1291
1292
1293
                    Get_Integer_Property
                      (Bound_Memory_Component,
                       "byte_count");
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
               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
1304
1305
1306
              (Loc (E),
               "You must provide the size of the parttion",
               Fatal => True);
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
         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
1319
1320
1321
               if Kind (F) = K_Port_Spec_Instance
                 and then Get_Connection_Pattern (F) = Inter_Process
               then
1322
1323

                  if Is_Defined_Property
1324
1325
1326
1327
1328
1329
1330
1331
                      (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)));
1332
                     CTU.Append_Node_To_List
1333
1334
1335
1336
1337
1338
1339
1340
                       (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)));
1341
                     CTU.Append_Node_To_List
1342
1343
                       (N,
                        CTN.Declarations (CTU.Current_File));
1344
1345
1346
1347
1348
1349
1350
1351
1352

                     Handle_Virtual_Buses_Properties (F);

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

                  AINU.Append_Node_To_List
1353
1354
                    (AINU.Make_Node_Container (F),
                     All_Ports);
1355
1356
1357

                  Handle_Buses_Connections (F);

1358
1359
1360
1361
1362
1363
                  N :=
                    Make_Expression
                      (CTU.Make_Defining_Identifier (Map_Port_Name (F)),
                       Op_Equal,
                       (Make_Literal
                          (CV.New_Int_Value (Local_Port_Identifier, 0, 10))));
1364
1365
                  Append_Node_To_List (N, Local_Port_List);

1366
1367
1368
1369
1370
1371
                  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))));
1372
1373
1374
                  Append_Node_To_List (N, Global_Port_List);

                  CTU.Append_Node_To_List
1375
1376
1377
1378
1379
                    (CTU.Copy_Node
                       (Get_Handling
                          (Bound_Processor,
                           By_Node,
                           H_C_Deployment_Spec)),
1380
1381
1382
                     CTN.Values (System_Partitions_Ports));
                  --  Declare which partition would use this port.

1383
                  Local_Port_Identifier  := Local_Port_Identifier + 1;
1384
1385
1386
                  Global_Port_Identifier := Global_Port_Identifier + 1;

                  CTU.Append_Node_To_List
1387
                    (Make_Literal (CV.New_Int_Value (Node_Identifier, 0, 10)),
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
                     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.
1409
1410
1411
               if AINU.Is_Data (Corresponding_Instance (C))
                 and then Is_Protected_Data (Corresponding_Instance (C))
               then
1412
1413
1414
1415
1416
1417

                  --  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.

1418
                  System_Nb_Lock_Objects  := System_Nb_Lock_Objects + 1;
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
                  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

1430
         O := CTU.Make_Literal (CV.New_Int_Value (Used_Memory_Size, 1, 10));
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443

         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;

1444
1445
1446
         CTU.Append_Node_To_List
           (CTU.Make_Literal (CV.New_Int_Value (Process_Nb_Threads, 1, 10)),
            CTN.Values (System_Partitions_Nb_Threads));
1447

1448
1449
1450
1451
         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));
1452
1453
1454

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

1455
1456
1457
1458
1459
1460
         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)));
1461
1462
1463
1464

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

         if Process_Nb_Buffers > 0 then
1465
1466
1467
1468
1469
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Buffers),
                 Value               =>
                   CTU.Make_Literal
1470
1471
1472
                     (CV.New_Int_Value (Process_Nb_Buffers, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

1473
1474
1475
1476
1477
            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));
1478
1479
1480
         end if;

         if Process_Nb_Events > 0 then
1481
1482
1483
1484
1485
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Events),
                 Value               =>
                   CTU.Make_Literal
1486
1487
1488
                     (CV.New_Int_Value (Process_Nb_Events, 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_Events),
                 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
1497
1498
1499
         end if;

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

         if Process_Nb_Blackboards > 0 then
1500
1501
1502
1503
1504
            N :=
              CTU.Make_Define_Statement
                (Defining_Identifier => RE (RE_Pok_Config_Nb_Blackboards),
                 Value               =>
                   CTU.Make_Literal
1505
1506
1507
                     (CV.New_Int_Value (Process_Nb_Blackboards, 1, 10)));
            CTU.Append_Node_To_List (N, CTN.Declarations (CTU.Current_File));

1508
1509
1510
1511
1512
            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));
1513
1514
1515
1516
1517
         end if;

         --  Define POK_NEEDS_MIDDLEWARE in each partition

         if Process_Nb_Blackboards > 0 or else Process_Nb_Buffers > 0 then
1518
1519
1520
1521
1522
            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));
1523
1524
         end if;

1525
1526
1527
1528
1529
         N :=
           CTU.Make_Define_Statement
             (Defining_Identifier => RE (RE_Pok_Config_Stacks_Size),
              Value               =>
                CTU.Make_Literal
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
                  (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;
1547
1548
1549
1550
         U : constant Node_Id :=
           CTN.Distributed_Application_Unit
             (CTN.Naming_Node (Backend_Node (Identifier (E))));
         P              : constant Node_Id := CTN.Entity (U);
1551