Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also compare across forks.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also compare across forks.
base fork: Dridus/rwars2012
base: 132ce1d60d
...
head fork: Dridus/rwars2012
compare: 1313e950a8
  • 2 commits
  • 9 files changed
  • 0 commit comments
  • 1 contributor
Commits on Sep 12, 2011
@Dridus child vms running, rig separated from payload, rig reports user time …
…elapsed and CPU shares appear to be honored. doesn't exit cleanly yet though
8e7af7a
Commits on Sep 13, 2011
@Dridus less buggy! still buggy though. 1313e95
View
1  agent/pom.xml
@@ -41,6 +41,7 @@
<dependencies>
<dependency><groupId>net.lag</groupId><artifactId>configgy</artifactId></dependency>
+ <dependency><groupId>org.clapper</groupId><artifactId>grizzled-slf4j_${scala.version}</artifactId></dependency>
<dependency><groupId>org.scala-lang</groupId><artifactId>scala-library</artifactId></dependency>
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId></dependency>
<dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId></dependency>
View
146 agent/src/main/java/rwars2012/agent/rig/Rig.java
@@ -0,0 +1,146 @@
+package rwars2012.agent.rig;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.ThreadMXBean;
+import java.util.IdentityHashMap;
+
+class Rig {
+ public static void main(String[] args) {
+ try {
+ new Rig().run(args);
+ } catch (Throwable t) {
+ System.err.println("throwable at top level:");
+ t.printStackTrace(System.err);
+ System.exit(2);
+ }
+ }
+
+ public void run(String[] args) throws Exception {
+ if (!supervisorPresent()) {
+ System.err.println("supervisor not present");
+ System.exit(1);
+ }
+
+ final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
+
+ if (!threadMXBean.isThreadCpuTimeSupported()) {
+ throw new UnsupportedOperationException("thread CPU time not supported by host VM");
+ }
+
+ threadMXBean.setThreadCpuTimeEnabled(true);
+
+ if (args.length != 1) {
+ System.err.println("missing payload");
+ System.exit(1);
+ }
+
+ final String payloadClassName = args[0];
+
+ long quantum = getSchedulingQuantum();
+ ThreadGroup payloadThreads = new ThreadGroup("payload");
+ registerPayloadThreadGroup(payloadThreads);
+
+ new RigCPUMonitor(threadMXBean, payloadThreads, quantum).start();
+
+ new Thread(payloadThreads, "Main Payload") {
+ public void run() {
+ try {
+ Class<? extends Runnable> payloadClass = Class.forName(payloadClassName).asSubclass(Runnable.class);
+
+ System.out.println("Rig loaded " + payloadClass.getName());
+
+ payloadClass.newInstance().run();
+ } catch (Exception e) {
+ System.err.println("exception in payload:");
+ e.printStackTrace(System.err);
+ }
+ }
+ }.start();
+ }
+
+ public boolean supervisorPresent() {
+ return false;
+ }
+
+ public void registerPayloadThreadGroup(ThreadGroup threadGroup) {
+ throw new UnsupportedOperationException("should have been handled by supervisor");
+ }
+
+ public long getSchedulingQuantum() {
+ throw new UnsupportedOperationException("should have been handled by supervisor");
+ }
+
+ public void reportUserTimeConsumed(long nanos) {
+ }
+
+ private class RigCPUMonitor extends Thread {
+ private ThreadMXBean threadMXBean;
+ private ThreadGroup payloadThreads;
+ private long sleepTime;
+ private IdentityHashMap<Thread, Long> nanosByThread = new IdentityHashMap<Thread, Long>();
+ private int runCount = 0;
+
+
+ public RigCPUMonitor(ThreadMXBean threadMXBean, ThreadGroup payloadThreads, long quantum) {
+ super("Rig CPU monitor");
+ setDaemon(true);
+ this.sleepTime = quantum / 2;
+ this.threadMXBean = threadMXBean;
+ this.payloadThreads = payloadThreads;
+ }
+
+ public void run() {
+ Thread[] activeThreads = null;
+
+ while (true) {
+ //System.out.println("monitoring cpu");
+
+ if (activeThreads == null) {
+ activeThreads = new Thread[payloadThreads.activeCount() + 5];
+ }
+
+ int threadsEnumerated;
+
+ do {
+ threadsEnumerated = payloadThreads.enumerate(activeThreads);
+ } while (threadsEnumerated >= activeThreads.length);
+
+ IdentityHashMap<Thread, Long> newNanosByThread = null;
+ if (++runCount % 1000 == 0) {
+ newNanosByThread = new IdentityHashMap<Thread, Long>(threadsEnumerated);
+ } else {
+ newNanosByThread = nanosByThread;
+ }
+
+ long userNanosConsumed = 0;
+
+ for (int i = 0; i < threadsEnumerated; ++i) {
+ Thread thread = activeThreads[i];
+ Long previousNanos = nanosByThread.get(thread);
+ long currentNanos = threadMXBean.getThreadUserTime(activeThreads[i].getId());
+ newNanosByThread.put(thread, currentNanos);
+ userNanosConsumed += currentNanos - (previousNanos != null ? previousNanos.longValue() : 0);
+ }
+
+ if (newNanosByThread != nanosByThread) {
+ nanosByThread = newNanosByThread;
+ }
+
+ reportUserTimeConsumed(userNanosConsumed);
+
+ if (threadsEnumerated < activeThreads.length - 5) {
+ // Allocate a smaller array next time since so many threads died
+ activeThreads = null;
+ }
+
+ try {
+ if (sleepTime > 0) {
+ Thread.sleep(sleepTime);
+ } else {
+ Thread.yield();
+ }
+ } catch (InterruptedException e) { }
+ }
+ }
+ }
+}
View
15 agent/src/main/java/rwars2012/agent/rig/TestPayload.java
@@ -0,0 +1,15 @@
+package rwars2012.agent.rig;
+
+public class TestPayload implements Runnable {
+ public void run() {
+ System.out.println("test payload up");
+
+ for (int i = 0; i < 1000000; i++) {
+ if (i % 1000 == 0) {
+ // System.out.println("test payload: " + i);
+ }
+ }
+
+ System.out.println("test payload down");
+ }
+}
View
2  agent/src/main/resources/logback.xml
@@ -5,7 +5,7 @@
</encoder>
</appender>
- <root level="debug">
+ <root level="trace">
<appender-ref ref="STDOUT" />
</root>
</configuration>
View
284 agent/src/main/scala/rwars2012/agent/ChildVM.scala
@@ -2,12 +2,13 @@ package rwars2012.agent
import java.io.{BufferedReader, File, InputStream, InputStreamReader, StringWriter}
import java.util.concurrent.{BrokenBarrierException, CyclicBarrier, Semaphore}
-import com.sun.jdi.{Bootstrap, ThreadReference, VirtualMachine}
+import com.sun.jdi.{Bootstrap, LongValue, ThreadGroupReference, ThreadReference, VirtualMachine}
import com.sun.jdi.connect.Connector.{BooleanArgument, StringArgument}
+import com.sun.jdi.event.EventSet
import com.sun.jdi.request.{StepRequest, ThreadDeathRequest, ThreadStartRequest}
+import grizzled.slf4j.Logger
import net.lag.configgy.Configgy
-import org.slf4j.{Logger, LoggerFactory}
-import scala.collection.JavaConverters.{mapAsScalaMapConverter, asScalaSetConverter}
+import scala.collection.JavaConverters.{asScalaBufferConverter, asScalaSetConverter, mapAsScalaMapConverter}
object ProcessStream extends Enumeration {
val STDIN = Value("stdin")
@@ -16,50 +17,42 @@ object ProcessStream extends Enumeration {
}
class ChildVMSupervisor(val quantum: Long) {
- val log = LoggerFactory.getLogger(getClass)
+ val log = Logger(getClass)
- private var barrier: CyclicBarrier = new CyclicBarrier(1)
+ private var barrier: CyclicBarrier = null
private var childVMs: Map[Int, ChildVM] = Map.empty
private var nextId: Int = 0
- private val supervisorThread = new Thread("ChildVM Supervisor " + System.identityHashCode(this)) {
- setDaemon(true)
-
- override def run() =
- while (true) {
- val b = synchronized(barrier)
- try {
- b.await()
- } catch {
- case (_: BrokenBarrierException) => {
- log.debug("barrier broken")
- run()
- }
- }
-
- log.debug("barrier converged")
- }
- }
-
- supervisorThread.start()
-
protected[agent] def converge(): Unit = {
val b = synchronized(barrier)
try {
+ log.trace("waiting on barrier " + b)
b.await()
} catch {
- case (_: BrokenBarrierException) => converge()
+ case (_: BrokenBarrierException) => {
+ log.debug("Barrier broken, re-converging")
+ converge()
+ }
}
}
- private def rebuildBarrier(newChildCount: Int): Unit = {
- barrier.reset()
- barrier = new CyclicBarrier(newChildCount + 1)
- }
+ private def rebuildBarrier(newChildCount: Int): Unit =
+ synchronized {
+ if (barrier != null) barrier.reset()
+
+ barrier =
+ if (newChildCount == 0) null
+ else new CyclicBarrier(newChildCount, new Runnable {
+ override def run() = log.trace("Barrier converged")
+ })
+
+ log.debug("rebuilding barrier for " + newChildCount)
+ notifyAll()
+ }
def add(label: String, parameters: VMParameters): ChildVM =
synchronized {
- rebuildBarrier(childVMs.size+1)
+ rebuildBarrier(childVMs.size + 1)
val newVM = new ChildVM(this, nextId, label, parameters)
childVMs += nextId -> newVM
nextId += 1
@@ -79,7 +72,7 @@ class ChildVMSupervisor(val quantum: Long) {
case class VMParameters(targetMainClass: String, targetJARs: Set[String], cpuShare: Int, maxHeap: Long, maxStack: Int)
class ChildVM protected[agent] (supervisor: ChildVMSupervisor, val id: Int, val label: String, val parameters: VMParameters) {
- val log = LoggerFactory.getLogger(getClass.getName + "#" + id + "-" + label)
+ val log = Logger(getClass.getName + "#" + id + "-" + label)
val virtualMachine: VirtualMachine = {
val agentJARPath = Configgy.config("agentJARPath")
@@ -90,48 +83,60 @@ class ChildVM protected[agent] (supervisor: ChildVMSupervisor, val id: Int, val
args("suspend").asInstanceOf[BooleanArgument].setValue(true)
args("options").asInstanceOf[StringArgument].setValue (
List (
- "-classpath " + (parameters.targetJARs + agentJARPath).mkString(File.pathSeparator),
+ "-classpath " + (
+ (parameters.targetJARs + agentJARPath)
+ .map(new File(_)).map(_.getAbsolutePath)
+ .mkString(File.pathSeparator)
+ ),
"-Xmx" + parameters.maxHeap,
"-Xss" + parameters.maxStack
).mkString(" ")
)
- args("main").asInstanceOf[StringArgument].setValue("rwars2012.agent.rig.Rig")
- log.info("Launching VM with arguments:")
+ args("main").asInstanceOf[StringArgument].setValue("rwars2012.agent.rig.Rig " + parameters.targetMainClass)
+ log.info("Launching VM with parameters: " + parameters + " and arguments:")
args.values.foreach(arg => log.info(" " + arg.toString))
- log.info("and parameters: " + parameters)
connector.launch(arguments)
}
- protected[agent] def kill(): Unit = {
- virtualMachine.exit(0)
- log.info("Killed.")
- }
+ var vmThreads: Map[ThreadReference, String] = Map.empty
+
+ protected[agent] def kill(): Unit =
+ if (synchronized(_monitor).isDefined) {
+ virtualMachine.exit(0)
+ log.info("Killed.")
+ }
private val stdoutStreamMonitor =
new StreamLogger("stdout", virtualMachine.process.getInputStream, s => log.info("stdout: " + s))
private val stderrStreamMonitor =
new StreamLogger("stderr", virtualMachine.process.getErrorStream, s => log.error("stderr: " + s))
-
+
val vmDeathRequest = virtualMachine.eventRequestManager.createVMDeathRequest()
val vmThreadStartRequest = virtualMachine.eventRequestManager.createThreadStartRequest()
val vmThreadDeathRequest = virtualMachine.eventRequestManager.createThreadDeathRequest()
- var vmThreads: Map[ThreadReference, String] = Map.empty
+ val classPrepareRequest = virtualMachine.eventRequestManager.createClassPrepareRequest()
- private var _stable: Boolean = false
+ classPrepareRequest.addClassFilter("rwars2012.agent.rig.Rig")
+
+ vmThreadStartRequest.enable()
+ vmThreadDeathRequest.enable()
+ vmDeathRequest.enable()
+ classPrepareRequest.enable()
+ private var _stableTime: Long = 0
+ private var _exitCode: Option[Int] = None
private var _monitor: Option[Monitor] = None
+ private var _payloadThreadGroup: Option[ThreadGroupReference] = None
+
def started: Boolean = _monitor.isDefined
- def stable: Boolean = _stable
+ def stable: Boolean = _stableTime > 0
def start(): Unit = synchronized {
_monitor match {
case None => {
log.info("Starting VM")
//virtualMachine.setDebugTraceMode(VirtualMachine.TRACE_ALL)
- vmThreadStartRequest.enable()
- vmThreadDeathRequest.enable()
- vmDeathRequest.enable()
_monitor = Some(new Monitor)
_monitor.get.start()
stdoutStreamMonitor.start()
@@ -143,19 +148,6 @@ class ChildVM protected[agent] (supervisor: ChildVMSupervisor, val id: Int, val
}
}
- def stop(): Unit = synchronized {
- _monitor match {
- case Some(th) => {
- _monitor = None
- notifyAll()
- th.interrupt()
- log.info("Stopping VM with parameters: " + parameters)
- }
-
- case None => sys.error("VM already stopped")
- }
- }
-
def waitForDeath(): Unit = synchronized {
_monitor match {
case None => log.debug("VM finished")
@@ -168,72 +160,152 @@ class ChildVM protected[agent] (supervisor: ChildVMSupervisor, val id: Int, val
}
private def clearMonitor(): Unit = synchronized {
- log.debug("clearing monitor")
- _monitor = None
- notifyAll()
- try { stdoutStreamMonitor.interrupt() } catch { case ex => log.debug("couldn't interrupt stdout:", ex) }
- try { stderrStreamMonitor.interrupt() } catch { case ex => log.debug("couldn't interrupt stderr:", ex) }
}
+ sealed abstract class EventProcessingResult
+ final case object MonitorFinished extends EventProcessingResult
+ final case class EventsProcessed(eventSet: EventSet) extends EventProcessingResult
+ final case object NoEventsToProcess extends EventProcessingResult
+
private class Monitor extends Thread(label + "-Monitor") {
- override def run(): Unit = {
- log.debug("Monitor starting")
- while (ChildVM.this.synchronized(_monitor).isDefined) {
- try {
- val events =
- if (!_stable) virtualMachine.eventQueue.remove // pend until any event while waiting for VM stability
- else virtualMachine.eventQueue.remove(supervisor.quantum)
-
- for (event <- if (events != null) events.asScala else Nil) {
- event match {
- case ThreadStart(vmThread) => {
- val name = vmThread.name
- log.info("VM thread starting: " + name)
- vmThreads += vmThread -> name
+ var cpuTimeThisSlice: Long = 0
+
+ private def handleEvents(maxTimeout: Long): EventProcessingResult = {
+ val events =
+ if (_stableTime == 0) virtualMachine.eventQueue.remove // pend until any event while waiting for VM stability
+ else virtualMachine.eventQueue.remove(maxTimeout)
+
+ if (events == null) log.trace("scheduling quantum expired")
+
+ for (event <- if (events != null) events.asScala else Nil) {
+ event match {
+ case ClassPrepare(klass) if klass.name == "rwars2012.agent.rig.Rig" => {
+ log.info("Rig class preparing")
+ classPrepareRequest.disable()
+ val methodEntryRequest = virtualMachine.eventRequestManager.createMethodEntryRequest()
+ methodEntryRequest.addClassFilter(klass)
+ methodEntryRequest.enable()
+ }
+
+ case MethodEntry(vmThread, method) => {
+ lazy val args = vmThread.frame(0).getArgumentValues.asScala
+ lazy val callText = method.name + args.mkString("(", ", ", ")")
+ method.name match {
+ case "supervisorPresent" => {
+ log.debug(callText + " => true")
+ vmThread.forceEarlyReturn(virtualMachine.mirrorOf(true))
}
- case ThreadDeath(vmThread) => {
- val name = vmThreads.get(vmThread) getOrElse "unknown"
- log.info("VM thread dying: " + name)
- vmThreads -= vmThread
+ case "registerPayloadThreadGroup" => {
+ log.debug(callText + " => {}")
+ _payloadThreadGroup = Some(args(0).asInstanceOf[ThreadGroupReference])
+ vmThread.forceEarlyReturn(virtualMachine.mirrorOfVoid)
}
- case VMDeath() => {
- log.info("VM dying - monitor exiting")
- clearMonitor()
- return
+ case "getSchedulingQuantum" => {
+ log.debug(callText + " => " + supervisor.quantum)
+ vmThread.forceEarlyReturn(virtualMachine.mirrorOf(supervisor.quantum))
}
- case VMStart(vmThread) => {
- log.info("VM started with initial thread: " + vmThread.name)
- _stable = true
+ case "reportUserTimeConsumed" => {
+ log.trace(callText + " => {}")
+ cpuTimeThisSlice += args(0).asInstanceOf[LongValue].value();
+ vmThread.forceEarlyReturn(virtualMachine.mirrorOfVoid)
}
- case _ => {}
+ case _ => log.trace(callText + " => ignored")
}
+ }
+
+ case ThreadStart(vmThread) => {
+ val name = vmThread.name
+ log.debug("VM thread starting: " + name)
+ vmThreads += vmThread -> name
+ }
+
+ case ThreadDeath(vmThread) => {
+ val name = vmThreads.get(vmThread) getOrElse "unknown"
+ log.debug("VM thread dying: " + name)
+ vmThreads -= vmThread
+ }
+
+ case VMDeath() => {
+ log.info("VM dying - monitor exiting")
+ events.resume()
+ return MonitorFinished
+ }
+
+ case VMStart(vmThread) => {
+ log.info("VM started with initial thread: " + vmThread.name)
+ _stableTime = System.currentTimeMillis
+ }
- supervisor.converge()
+ case VMDisconnect() => {
+ log.info("VM disconnected")
+ return MonitorFinished
+ }
+
+ case _ => log.trace("ignoring " + event)
+ }
+ }
- for ((vmThread, name) <- vmThreads if vmThread.isSuspended) {
- log.debug("Thread " + name + " is suspended - resuming it")
- vmThread.resume()
+ if (_stableTime == 0) handleEvents(maxTimeout)
+ else Option(events).map(EventsProcessed.apply) getOrElse NoEventsToProcess
+ }
+
+ override def run(): Unit = {
+ log.debug("Monitor starting")
+ while (ChildVM.this.synchronized(_monitor).isDefined) {
+ try {
+ def convergeIfNeeded() =
+ if (cpuTimeThisSlice >= parameters.cpuShare) {
+ log.trace("CPU share exhausted, converging")
+ virtualMachine.suspend()
+ supervisor.converge()
+ cpuTimeThisSlice = 0
+ virtualMachine.resume()
}
- log.debug("Resuming the virtual machine")
- virtualMachine.resume()
+ handleEvents(supervisor.quantum) match {
+ case _ if !ChildVM.this.synchronized(_monitor).isDefined => {}
+ case MonitorFinished =>
+ ChildVM.this.synchronized {
+ log.debug("clearing monitor")
+ _monitor = None
+ ChildVM.this.notifyAll()
+ }
+ case EventsProcessed(events) => {
+ convergeIfNeeded()
+ log.trace("Resuming via EventSet")
+ events.resume()
+ }
+
+ case NoEventsToProcess => {
+ convergeIfNeeded()
+ log.trace("Resuming the virtual machine")
+ virtualMachine.resume()
+ }
}
} catch {
case (ie: InterruptedException) => {}
- case (ex: Exception) => {
- log.error("Monitor dying: ", ex)
- clearMonitor()
- return
- }
+ case (ex: Exception) => log.error("Monitor dying: ", ex)
}
}
- log.debug("Monitor exiting")
- clearMonitor()
+
+ try { stdoutStreamMonitor.interrupt() } catch { case ex => log.debug("couldn't interrupt stdout:", ex) }
+ try { stderrStreamMonitor.interrupt() } catch { case ex => log.debug("couldn't interrupt stderr:", ex) }
+ supervisor.remove(ChildVM.this)
+
+ log.debug("Waiting for VM process to exit")
+ _exitCode = Some(virtualMachine.process.waitFor())
+ if (_exitCode.get == 0) {
+ log.info("Virtual machine exited with success after running for " +
+ (System.currentTimeMillis - _stableTime) + "ms")
+ } else {
+ log.warn("Virtual machine exited with code " + _exitCode.get + " after running for " +
+ (System.currentTimeMillis - _stableTime) + "ms")
+ }
}
}
@@ -251,8 +323,6 @@ class ChildVM protected[agent] (supervisor: ChildVMSupervisor, val id: Int, val
}
} catch {
case ex => log.info("Died:", ex)
- } finally {
- log.debug("Finished.")
}
}
}
View
29 agent/src/main/scala/rwars2012/agent/JDIScala.scala
@@ -1,7 +1,14 @@
package rwars2012.agent
-import com.sun.jdi.{Location, ThreadReference}
-import com.sun.jdi.event.{Event, StepEvent, ThreadDeathEvent, ThreadStartEvent, VMDeathEvent, VMStartEvent}
+import com.sun.jdi.{Location, ReferenceType, ThreadReference}
+import com.sun.jdi.event.{
+ Event,
+ ClassPrepareEvent,
+ MethodEntryEvent,
+ StepEvent,
+ ThreadDeathEvent, ThreadStartEvent,
+ VMDeathEvent, VMStartEvent, VMDisconnectEvent
+}
object Step {
def unapply(in: Event): Option[(ThreadReference, Location)] = in match {
@@ -10,6 +17,20 @@ object Step {
}
}
+object ClassPrepare {
+ def unapply(in: Event): Option[ReferenceType] = in match {
+ case (classPrepare: ClassPrepareEvent) => Some(classPrepare.referenceType)
+ case _ => None
+ }
+}
+
+object MethodEntry {
+ def unapply(in: Event): Option[(ThreadReference, com.sun.jdi.Method)] = in match {
+ case (methodEntry: MethodEntryEvent) => Some(methodEntry.thread, methodEntry.method)
+ case _ => None
+ }
+}
+
object ThreadDeath {
def unapply(in: Event): Option[ThreadReference] = in match {
case (threadDeath: ThreadDeathEvent) => Some(threadDeath.thread)
@@ -34,3 +55,7 @@ object VMStart {
case _ => None
}
}
+
+object VMDisconnect {
+ def unapply(in: Event): Boolean = in.isInstanceOf[VMDisconnectEvent]
+}
View
15 agent/src/main/scala/rwars2012/agent/Rig.scala
@@ -1,15 +0,0 @@
-package rwars2012.agent.rig
-
-object Rig extends App {
- println("rig up")
-
- var i = 0
- while (i < 1000000) {
- if (i % 1000 == 0) {
- println("rig at " + i)
- }
- i += 1
- }
-
- println("rig down")
-}
View
12 agent/src/main/scala/rwars2012/agent/Test.scala
@@ -1,18 +1,18 @@
package rwars2012.agent
import net.lag.configgy.Configgy
-import org.slf4j.LoggerFactory
+import grizzled.slf4j.Logger
object Test extends App {
- val log = LoggerFactory.getLogger(getClass)
+ val log = Logger(getClass)
Configgy.configure(args(0))
- val supervisor = new ChildVMSupervisor(10)
+ val supervisor = new ChildVMSupervisor(4)
val childvms = List (
- supervisor.add("first", VMParameters("foo", Set.empty, 10, 1024*1024, 256*1024)),
- supervisor.add("second", VMParameters("bar", Set.empty, 20, 1024*1024, 256*1024)),
- supervisor.add("third", VMParameters("baz", Set.empty, 30, 1024*1024, 256*1024))
+ supervisor.add("first", VMParameters("rwars2012.agent.rig.TestPayload", Set.empty, 1000000, 1024*1024, 256*1024)),
+ supervisor.add("second", VMParameters("rwars2012.agent.rig.TestPayload", Set.empty, 2000000, 1024*1024, 256*1024)),
+ supervisor.add("third", VMParameters("rwars2012.agent.rig.TestPayload", Set.empty, 3000000, 1024*1024, 256*1024))
)
childvms.foreach(_.start())
View
15 pom.xml
@@ -95,6 +95,16 @@
<dependencyManagement>
<dependencies>
<dependency>
+ <groupId>ch.qos.logback</groupId>
+ <artifactId>logback-classic</artifactId>
+ <version>0.9.29</version>
+ </dependency>
+ <dependency>
+ <groupId>org.clapper</groupId>
+ <artifactId>grizzled-slf4j_${scala.version}</artifactId>
+ <version>0.6.6</version>
+ </dependency>
+ <dependency>
<groupId>net.lag</groupId>
<artifactId>configgy</artifactId>
<version>2.0.0</version>
@@ -127,11 +137,6 @@
<artifactId>slf4j-api</artifactId>
<version>1.6.2</version>
</dependency>
- <dependency>
- <groupId>ch.qos.logback</groupId>
- <artifactId>logback-classic</artifactId>
- <version>0.9.29</version>
- </dependency>
</dependencies>
</dependencyManagement>
</project>

No commit comments for this range

Something went wrong with that request. Please try again.