Changes in / [3c6480b7:36ec816]


Ignore:
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/bits/multi_list.cfa

    r3c6480b7 r36ec816  
    22#include <stdlib.hfa>
    33#include "sequence.hfa"
    4 #include "queue.hfa"
    54#include "stack.hfa"
    65
     
    98struct TaskDL {
    109        inline Seqable;
    11         Task & node;
     10        Task & task_;
    1211};
    1312void ?{}( TaskDL & this, Task & task ) with( this ) {
    1413        ((Seqable &)this){};
    15         &node = &task;                                                                          // pointer to containing node
     14        &task_ = &task;                                                                         // pointer to containing node
    1615}
    1716Task & task( TaskDL & this ) with( this ) {                             // getter routine for containing node
    18         return node;
    19 }
    20 
    21 struct TaskSL {
    22         inline Colable;
    23         Task & node;
    24 };
    25 void ?{}( TaskSL & this, Task & task ) with( this ) {
    26         ((Colable &)this){};
    27         &node = &task;                                                                          // pointer to containing node
    28 }
    29 Task & task( TaskSL & this ) with( this ) {                             // getter routine for containing node
    30         return node;
     17        return task_;
    3118}
    3219
     
    3421        TaskDL clusterRef;                                                                      // list of tasks on cluster
    3522        TaskDL readyRef;                                                                        // list of tasks on ready queue
    36         TaskSL mutexRef;                                                                        // list of tasks on mutex queue
    37         int id;
     23        // other stuff
    3824};
    39 void ?{}( Task & this, int id ) with( this ) {
     25void ?{}( Task & this ) with( this ) {
    4026        ((TaskDL &)clusterRef){ this };
    4127        ((TaskDL &)readyRef){ this };
    42         ((TaskSL &)mutexRef){ this };
    43         this.id = id;
    4428}
    4529
    4630int main() {
    4731        Sequence(TaskDL) clustList, readyList;                          // task lists
    48         Queue(TaskSL) mutexList;
    4932        enum { Lnth = 10 };
    5033
    51         for ( id; Lnth ) {
    52                 Task & task = *new( id );                                               // create task node
     34        for ( Lnth ) {
     35                Task & task = *new();                                                   // create task node
    5336                addHead( clustList, task.clusterRef );                  // insert on lists in opposite directions
    5437                addTail( readyList, task.readyRef );
    55                 addHead( mutexList, task.mutexRef );
    5638        }
    5739
    58         SeqIter(TaskDL) sqiter;
     40        SeqIter(TaskDL) iter;
    5941        TaskDL & dl;
    60         TaskSL & sl;
    6142
    6243        sout | nlOff;
    63         for ( over( sqiter, clustList ); sqiter >> dl; ) {      // print lists
    64                 Task & tmp = task( dl ); sout | tmp.id;
    65                 // sout | task( dl ).id;
     44        for ( over( iter, clustList ); iter >> dl; ) {          // print lists
     45                sout | &task( dl );
    6646        }
    6747        sout | nl;
    68         for ( over( sqiter, readyList ); sqiter >> dl; ) {
    69                 Task & tmp = task( dl ); sout | tmp.id;
    70                 // sout | task( dl ).id;
     48        for ( SeqIter(TaskDL) iter = { readyList }; iter >> dl; ) {
     49                sout | &task( dl );
    7150        }
    7251        sout | nl;
    73         for ( QueueIter(TaskSL) qiter = { mutexList }; qiter >> sl; ) { // print lists
    74                 Task & tmp = task( sl ); sout | tmp.id;
    75                 // sout | task( sl ).id;
     52        for ( Lnth ) {                                                                          // remove nodes from clustList
     53                dropHead( clustList );
    7654        }
    77         sout | nl;
    78         for ( Lnth ) {                                                                          // remove nodes from clustList. mutexList
    79                 dropHead( clustList );
    80                 drop( mutexList );
    81         }
    82         // Simultaneous deletion only safe if all nodes are traversed in same direction.
    8355        for ( Lnth ) {                                                                          // remove nodes from readyList and safe to delete nodes
    8456                delete( &task( dropHead( readyList ) ) );
    8557        }
    8658
    87         // Re-purpose Seqable as Colable
    88         Stack(TaskDL) mutexStack;
    89         for ( id; Lnth ) {
    90                 Task & task = *new( id );                                               // create task node
    91                 push( mutexStack, task.clusterRef );                    // insert on lists in opposite directions
    92         }
    93         for ( StackIter(TaskDL) stiter = { mutexStack }; stiter >> dl; ) {
    94                 Task & tmp = task( dl ); sout | tmp.id;
    95                 // sout | task( dl ).id;
    96         }
    97         sout | nl;
    98         for ( Lnth ) {                                                                          // remove nodes from readyList and safe to delete nodes
    99                 delete( &task( pop( mutexStack ) ) );
    100         }
     59        // Stack(TaskDL) fredStack;
     60        // for ( Lnth ) {
     61        //      Task & task = *new();                                                   // create task node
     62        //      push( fredStack, task.clusterRef );                             // insert on lists in opposite directions
     63        // }
    10164}
  • libcfa/src/bits/sequence.hfa

    r3c6480b7 r36ec816  
    211211        struct SeqIter {
    212212                inline ColIter;
    213                 // The Sequence must be passed to pred and succ to check for the end of the Sequence and return 0p. Without
    214                 // passing the sequence, traversing would require its length. Thus the iterator needs a pointer to the sequence
    215                 // to pass to succ/pred. Both stack and queue just encounter 0p since the lists are not circular.
    216213                Sequence(T) * seq;
    217214        };
     
    254251        struct SeqIterRev {
    255252                inline ColIter;
    256                 // See above for explanation.
    257253                Sequence(T) * seq;
    258254        };
  • tests/.expect/manipulatorsOutput2.arm64.txt

    r3c6480b7 r36ec816  
    11
    220b0 0b11011 0b11011 0b11011 0b11011
    3 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b1111111111111111111111111111111111111111111111111111111111100101
     30b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b11111111111111111111111111100101
    440 033 033 033 033
    5 0345 0177745 037777777745 01777777777777777777745
     50345 0177745 037777777745 037777777745
    660 0x1b 0x1b 0x1b 0x1b
    7 0xe5 0xffe5 0xffffffe5 0xffffffffffffffe5
    8 0x0p+0. 0x1.b8p+4 0x1.b8p+4 0x1.b8p+4
    9 -0x1.b8p+4 -0x1.b8p+4 -0x1.b8p+4
     70xe5 0xffe5 0xffffffe5 0xffffffe5
     80x0p+0. 0x1.b8p+4 0x1.b8p+4 0xd.cp+1
     9-0x1.b8p+4 -0x1.b8p+4 -0xd.cp+1
    10100.000000e+00 2.750000e+01 -2.750000e+01
    11110B11011 0X1B 2.75E-09 0X1.B8P+4
Note: See TracChangeset for help on using the changeset viewer.