diff --git a/readme.md b/readme.md
index 60ceac2c671bbb36af5be299bd3ea6e36ead4d18..88ff826b5e49cc516c7963f83953136183eeac9b 100644
--- a/readme.md
+++ b/readme.md
@@ -4,8 +4,66 @@
 ## Description
 An implementation of various Load Balancing schemes, to examine the concepts of Isoefficiency.
 
+Program uses the MPI library to launch multiple, distinct processes to simulate "distinct machines with separate, distributed memory".
+
+Note that program will launch minimum of four processes.
+* Exactly one "main" processor, to manage "console output" for user display.
+* At minimum, three more "worker" processor, to simulate the given load scheme.
+
+Regardless of processes launched or load scheme chosen, program will initialize with all loads on the first worker process. All other worker processes will attempt to get loads to work on. Manner in which they attempt to get loads varies based on load scheme chosen.
+
+Program continues until all worker threads have completed all loads. A process will not split work if it has less than 10 loads left.
+
+### Load Schemes
+Possible load schemes are:
+ * (ARR) Asyncronous Round Robin
+ * (GRR) Global Round Robin
+ * (RP) Random Polling
+ * (NN) Nearest Neighbor
+
+There is no "user friendly" way to select a load scheme. It must be done by manually commenting out a line in `main.c` and recompiling the program.
+
 
 ## Running the Program
-Compile with `make all`.
+First, edit main.c, around line 210, and uncomment out only the schema you wish to run.
+
+Then run one of the below following commands.
+
+In both cases, args are required, in order:
+ * Arg 1 - "Seconds per Load" - Indicates how many seconds each load of "work" should take.
+ * Arg 2 - "Total Loads" - Total number of loads to launch program with.
+
+### Compile and Run, Utilizing Number of Processes Equal to Computer Cores
+
+    make run
+
+### Compile and Run, Utilizing a manually set Number of Processes
+Compile with:
+
+    make all
+
+Run program with:
+
+    mpiexec -n <number_of_processes> --oversubscribe ./main.out <args>
+
+Where:
+ * `<number_of_processes>` - Is replaced by an integer declaring the number of processes to launch the program with.
+ * `<args>` - Is replaced with desired program args, described above.
+
+
+## Known Issues
+### Simulation of Work
+Work is simulated by simply sleeping for the number of seconds indicated by command line arg 1 (seconds per load).
+
+Ideally, each individual worker thread would wait this time. However, due to issues I was not able to resolve, sleeping the workers seemed to (inconsistently) freeze them and result in no further output sent to the main process, from the given sleeping worker.
+
+My solution was to simply have the main process handle the sleeps instead, after processing a status request from each worker thread. Each worker thread then uses a blocking send until the main process responds, thus forcing all processes to "sleep".
+
+It's not ideal, and results in slightly worse runtime speeds than would otherwise occur, but at least the general goals of the program are still met.
+
+### Running Multiple Load Schemes in One Runtime Execution
+Uncommenting multiple load schemes, in theory, should just run them all one after another.
+
+However, in its current state, doing so results in multiple processes having pending messages from the previous load schema run, which depending on the message may affect overall runtime of the current load schema run.
 
-Run program with `./main.out`.
+Thus it's not recommended to run multiple load schemas run in one single program execution. Only uncomment out one at a time, per runtime.