The document discusses using Go to run simulation apps in parallel while keeping them synchronized. It describes using shared memory and message passing between processes to delegate simulation work to DLLs and coordinate their execution. Key points include spawning goroutines to handle requests concurrently, suspending tasks if not ready, and flushing suspended tasks when conditions are ready to proceed in parallel while staying synchronized. The goal is to leverage Go's concurrency features to efficiently run multiple simulation objects in parallel instead of serially while maintaining sync between processes.

1. My client wanted their apps synced,
and I made it with Go
@torufurukawa
Toru Furukawa

2. Can you run apps in parallel?
Yes, I guess

3. I will send purchase order.

5. Solver simulates only 1 Object
Solver
(app/DLL)
Wrapper app

6. SimulaMng mulMple objects serially
Solver
ControlWrapper Wrapper
Swaps internal variables

7. Want to run them
in parallel and synced
ControlWrapper Wrapper
Wrapper
Wrapper
(concurrent)

8. Concurrency? Sync? Go!
hOps://talks.golang.org/2012/waza.slide#14

9. • Concurrency
• Messaging (data exchange)
• SynchronizaMon

10. Process
Lib memory
DLL simulates an object's behavior
DLL
Load

11. Delegate simulaMon to DLL func
dll, err := syscall.LoadDLL(path)
proc := dll.MustFindProc("simulate")
...
for {
ret, _, err := proc.Call(...)
ret != 0{
break
}
}

12. Make another DLL to call solver DLL
wrap_f(double *x) {
*x = f();
}
Go app
Wrapper DLL
wrap_f()
Solver DLL
f()

13. Process
Lib
memory
Concurrency
Process
Lib
memory
DLL file
Load
Process
Lib
memory

14. Add message broker
Process Process Process
Message Broker

15. Listen, Accept and Handle
func main() {
...
ch := make(chan event)
go listenAndServe(ch, ...)
...
}

16. Listen, Accept and Handle
func listenAndServe(chan event) {
ln, err := net.Listen(…)
for {
conn, err := ln.Accept()
go handleConn(conn, ch)
}
}

17. Handle Requests
func handleConn(...) {
for {
req := read(conn)
respCh := make(chan …)
ch <- event{req,
respCh}
resp := <- respCh
write(conn, resp)
}
}
func main() {
…
for {
e := <- ch
result = do(e.req)
e.respCh <- result
}
}

18. Messaging
Process Process Process
Message Broker
SET SET SET GET

19. Need all processes synced
Process A
Time
Process B
Process C

20. Suspend task if not ready
func main() {
...
for {
event := <- ch
if !ready(event.req) {
tasks = append(tasks,
func() {do(event.req)})
continue
}
result = do(event.req)
...
}

21. Flush tasks when ready
func main() {
...
if readyToFlush(...) {
for _, t := range tasks {
t()
}
tasks := make([]task, 0)
}
...
}

22. Sync
Process A
Time
Process B
Process C

23. Concurrency? Sync? Go!

24. Just shipped last week
@torufurukawa