Create a CPU Proxy Component

[faustus123]

Create an ERSAP actor in C++ that simulates a CPU component.

The actor should be configurable such that it can:

• exercise N cores with dummy calculations
• read data from a socket (UDP, TCP, unix)
• write fraction of data to a socket (UDP, TCP, unix)
• configure the "burstiness" of the CPU usage and outputs

[faustus123]

This is getting a little ahead of ourselves. This is actually Milestone M15 which is scheduled for Y2Q1 in the proposal.

[cissieAB]

@faustus123 Please read the below and share what you think

If you do not need meaningful output, let's approximate it with matrix multiplication.
Think of Ax=y where x & y are vectors, x is the incoming data bandwidth (BW), y is the outgoing BW. Say x's dimension is 10000 (row#)x1(column#), if we want the output to be 200x1, we can generate a matrix of random numbers with a dimension of 200 x 10000(column#) thus you can control the output volume based on the input volume. We need this matrix to be large enough to make the CPU compute bound. So instead x&y are vectors, we make them matrices, e.g., x is of dimension 10000x65536 and y is of 200x65536. We can still use the row number of the matrix to mimic the incoming/outgoing BW.

If this matrix multiplication is too fast, we can add some loops, like Ax=y, A_{inverse}y=x, ..., Ax=y to obtain the desired speed. We can compute A_inverse ahead to save the time.

If you want this proxy running on ifarm, we need to do some benchmarking (reading from socket + matrix multiplication of several loops + sending via socket) to get the relationship of:

• Execution time (y axis) vs output/input fraction (x axis): fix the input matrix dimension, adjust the output matrix dimension.
• Execution time (y axis) vs inner loop number(x axis): fix the input and output matrix dimension, adjust the inner loop number.
  We expect a linear relationship for both of the above.

If the benchmarking result agree with our expectation, we can use the 1. input/output fraction 2. inner loop to construct our proxy.

[goodrich-rogue]

Interesting idea. We could pass some parms to the emulator so that a 10MB input event (e.g., EIC) approaches the 2GB mem process limit without exceeding it and another to scale the computational effort and another to control sleeping for latency or incurring it. How about a last one for the number of thread or cores?