[5adf4f4] | 1 | import akka.actor.typed.scaladsl.Behaviors |
---|
| 2 | import akka.actor.typed.scaladsl.LoggerOps |
---|
| 3 | import akka.actor.typed.{ ActorRef, ActorSystem, Behavior } |
---|
| 4 | import java.util.concurrent.atomic.AtomicInteger |
---|
| 5 | import akka.event.Logging |
---|
| 6 | import akka.actor.typed.DispatcherSelector |
---|
| 7 | import java.util.concurrent.Semaphore |
---|
| 8 | |
---|
| 9 | object ExecutorActor { |
---|
| 10 | sealed trait MessageTypes |
---|
| 11 | final case class Dummy( id: Int ) extends MessageTypes |
---|
| 12 | final case class StartMsg( id: Int ) extends MessageTypes |
---|
| 13 | |
---|
| 14 | val rounds = ExecutorMain.Set * ExecutorMain.Rounds |
---|
| 15 | |
---|
| 16 | def apply(): Behavior[MessageTypes] = Behaviors.receive { (context, message) => |
---|
| 17 | message match { |
---|
| 18 | case StartMsg( id ) => |
---|
| 19 | ExecutorMain.groups(id) = id / ExecutorMain.Set * ExecutorMain.Set |
---|
| 20 | if (id == ExecutorMain.Actors - 1) { |
---|
| 21 | ExecutorMain.system ! ExecutorMain.Continue() |
---|
| 22 | } // if |
---|
| 23 | case Dummy( id ) => |
---|
| 24 | if ( ExecutorMain.recs(id) >= rounds ) { |
---|
| 25 | if ( ExecutorMain.actorCnt.incrementAndGet() == ExecutorMain.Actors ) { |
---|
| 26 | if ( ExecutorMain.trials.get() > 0 ) { // ignore trial 1 |
---|
| 27 | println( s"${ExecutorMain.Processors}" + "\t" + f"${(System.nanoTime() - ExecutorMain.startTime) * ExecutorMain.Factor / 1_000_000_000.0}%1.2f" ) |
---|
| 28 | } // if |
---|
| 29 | if ( ExecutorMain.trials.incrementAndGet() == ExecutorMain.Numtimes + 1 ) { |
---|
| 30 | ExecutorMain.system ! ExecutorMain.Stop() |
---|
| 31 | } else { |
---|
| 32 | ExecutorMain.actorCnt.set( 0 ) |
---|
| 33 | ExecutorMain.startTime = System.nanoTime() |
---|
| 34 | for ( r <- 0 until ExecutorMain.Actors ) { // start actors again |
---|
| 35 | ExecutorMain.actors(r) ! Dummy( r ) |
---|
| 36 | } // for |
---|
| 37 | } // if |
---|
| 38 | } // if |
---|
| 39 | ExecutorMain.recs(id) = 0 |
---|
| 40 | ExecutorMain.sends(id) = 0 // reset for next trial |
---|
| 41 | } else { |
---|
| 42 | if ( ExecutorMain.recs(id) % ExecutorMain.Batch == 0 ) { |
---|
| 43 | for ( r <- 0 until ExecutorMain.Batch ) { // start actors again |
---|
| 44 | val sendId = ExecutorMain.groups(id) + ExecutorMain.sends(id) % ExecutorMain.Set |
---|
| 45 | ExecutorMain.actors( sendId ) ! Dummy( sendId ) // cycle through group |
---|
| 46 | ExecutorMain.sends(id) += 1 |
---|
| 47 | } // for |
---|
| 48 | } // if |
---|
| 49 | ExecutorMain.recs(id) += 1 |
---|
| 50 | } // if |
---|
| 51 | } // message |
---|
| 52 | Behaviors.same |
---|
| 53 | } |
---|
| 54 | } |
---|
| 55 | |
---|
| 56 | object ExecutorMain { |
---|
| 57 | sealed trait MainMessages |
---|
| 58 | final case class Start() extends MainMessages |
---|
| 59 | final case class Stop() extends MainMessages |
---|
| 60 | final case class Continue() extends MainMessages |
---|
| 61 | |
---|
| 62 | var Actors = 40_000; var Set = 100; var Rounds = 400; var Processors = 1; var Batch = 1; var Numtimes = 1; var Factor = 2 // default values |
---|
| 63 | |
---|
| 64 | val actors = new Array[ActorRef[ExecutorActor.MessageTypes]](Actors) |
---|
| 65 | val recs = new Array[Int](Actors) |
---|
| 66 | val sends = new Array[Int](Actors) |
---|
| 67 | val groups = new Array[Int](Actors) |
---|
| 68 | |
---|
| 69 | val actorCnt = new AtomicInteger(0) |
---|
| 70 | val trials = new AtomicInteger(0) |
---|
| 71 | val sem = new Semaphore(0) |
---|
| 72 | |
---|
| 73 | var system : ActorSystem[ExecutorMain.MainMessages] = null |
---|
| 74 | var startTime = System.nanoTime() |
---|
| 75 | |
---|
| 76 | def apply(): Behavior[MainMessages] = Behaviors.setup { context => |
---|
| 77 | for ( id <- 0 until Actors ) { // create actors |
---|
| 78 | recs(id) = 0 |
---|
| 79 | sends(id) = 0 |
---|
| 80 | actors(id) = context.spawn(ExecutorActor(), "actor_" + id, DispatcherSelector.fromConfig("akka.dispatcher")) |
---|
| 81 | } // for |
---|
| 82 | |
---|
| 83 | Behaviors.receiveMessage { message => |
---|
| 84 | message match { |
---|
| 85 | case Start() => |
---|
| 86 | for ( id <- 0 until Actors ) { // start actors |
---|
| 87 | actors(id) ! ExecutorActor.StartMsg( id ) |
---|
| 88 | } // for |
---|
| 89 | Behaviors.same |
---|
| 90 | case Continue() => |
---|
| 91 | for ( id <- 0 until Actors ) { // start actors |
---|
| 92 | actors(id) ! ExecutorActor.Dummy( id ) |
---|
| 93 | } // for |
---|
| 94 | Behaviors.same |
---|
| 95 | case Stop() => |
---|
| 96 | sem.release() |
---|
| 97 | Behaviors.stopped |
---|
| 98 | } // match |
---|
| 99 | } |
---|
| 100 | } |
---|
| 101 | |
---|
| 102 | def usage() = { |
---|
| 103 | println( "Usage: " + |
---|
| 104 | s"[ actors (> 0 && > set && actors % set == 0 ) | 'd' (default ${Actors}) ] " + |
---|
| 105 | s"[ set (> 0) | 'd' (default ${Set}) ] " + |
---|
| 106 | s"[ rounds (> 0) | 'd' (default ${Rounds}) ] " + |
---|
| 107 | s"[ processors (> 0) | 'd' (default ${Processors}) ] " + |
---|
| 108 | s"[ batch (> 0) | 'd' (default ${Batch}) ] " + |
---|
| 109 | s"[ num times (> 0) | 'd' (default ${Numtimes}) ]" |
---|
| 110 | ) |
---|
| 111 | System.exit( 1 ) |
---|
| 112 | } |
---|
| 113 | |
---|
| 114 | def main(args: Array[String]): Unit = { |
---|
| 115 | if ( args.length > 7 ) usage() // process command-line arguments |
---|
| 116 | if ( args.length == 7 ) { |
---|
| 117 | if ( args(6) != "d" ) { // default ? |
---|
| 118 | Factor = args(6).toInt |
---|
| 119 | if ( Factor < 1 ) usage() |
---|
| 120 | } // if |
---|
| 121 | } // if |
---|
| 122 | if ( args.length >= 6 ) { |
---|
| 123 | if ( args(5) != "d" ) { // default ? |
---|
| 124 | Numtimes = args(5).toInt |
---|
| 125 | if ( Numtimes < 1 ) usage() |
---|
| 126 | } // if |
---|
| 127 | } // if |
---|
| 128 | if ( args.length >= 5 ) { |
---|
| 129 | if ( args(4) != "d" ) { // default ? |
---|
| 130 | Batch = args(4).toInt |
---|
| 131 | if ( Batch < 1 ) usage() |
---|
| 132 | } // if |
---|
| 133 | } // if |
---|
| 134 | if ( args.length >= 4 ) { |
---|
| 135 | if ( args(3) != "d" ) { // default ? |
---|
| 136 | Processors = args(3).toInt |
---|
| 137 | if ( Processors < 1 ) usage() |
---|
| 138 | } // if |
---|
| 139 | } // if |
---|
| 140 | if ( args.length >= 3 ) { // fall through |
---|
| 141 | if ( args(2) != "d" ) { // default ? |
---|
| 142 | Rounds = args(2).toInt |
---|
| 143 | if ( Rounds < 1 ) usage() |
---|
| 144 | } // if |
---|
| 145 | } // if |
---|
| 146 | if ( args.length >= 2 ) { // fall through |
---|
| 147 | if ( args(1) != "d" ) { // default ? |
---|
| 148 | Set = args(1).toInt |
---|
| 149 | if ( Set < 1 ) usage() |
---|
| 150 | } // if |
---|
| 151 | } // if |
---|
| 152 | if ( args.length >= 1 ) { // fall through |
---|
| 153 | if ( args(0) != "d" ) { // default ? |
---|
| 154 | Actors = args(0).toInt |
---|
| 155 | if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) usage() |
---|
| 156 | } // if |
---|
| 157 | } // if |
---|
| 158 | |
---|
| 159 | Rounds = Rounds / Factor; |
---|
| 160 | |
---|
| 161 | //println( "Actors " + Actors + " Set " + Set + " Rounds " + Rounds + " Processors " + Processors + " Batch " + Batch ) |
---|
| 162 | |
---|
| 163 | system = ActorSystem( ExecutorMain(), "Executor" ) |
---|
| 164 | system ! Start() |
---|
| 165 | sem.acquire() |
---|
| 166 | } |
---|
| 167 | } |
---|
| 168 | |
---|
| 169 | // Local Variables: // |
---|
| 170 | // tab-width: 4 // |
---|
| 171 | // mode: java // |
---|
| 172 | // compile-command: "sbt --warn -J-Xmx32g \"run\"" // |
---|
| 173 | // End: // |
---|