pmap

I'm trying to better understand how pmap() works within dataframes, and I get a surprising result when applying pmap() to compute means from several columns. mtcars %>% mutate(comp_var = pmap_dbl(list(vs, am, cyl), mean)) %>% select(comp_var, vs, am, cyl) In the above example, comp_var is equal to the value of vs in its row, rather than the mean of the three variables in a given row. I know that I could get accurate results for comp_var using ... mtcars %>% rowwise() %>% mutate(comp_var = mean(c(vs, am, cyl))) %>% select(comp_var, vs, am, cyl) %>% ungroup() ... but I want to understand how

I am building a microsimulation model in Julia. I have built the structure of my function and it runs great for for 1 "person". I'd like to write the script to run 100000+ people through the model and save the results in one location. Eventually I'd like to execute this in parallel. Below I have included a simple working version of the code with dummy probabilities. using Distributions # Microsim function function MicroSim(start_age, stages) stage = 0 age = start_age # Set all trackers to 0 Death_tracker = 0 Disease_tracker = 0 # While loop while stage <= stages age = age #####################

The documentation on the pmap function leaves me wondering how efficient it would be for something like fetching a collection of XML feeds over the web. I have no idea how many concurrent fetch operations pmap would spawn and what the maximum would be. If you check the source you see: > (use 'clojure.repl) > (source pmap) (defn pmap "Like map, except f is applied in parallel. Semi-lazy in that the parallel computation stays ahead of the consumption, but doesn't realize the entire result unless required. Only useful for computationally intensive functions where the time of f dominates the

JDK version is hotspot 8u_45 I researched native memory of my java process. The native memory even consumes more space than heap. However there are many native memory blocks which confuses me. The result of pmap -x for example: 00007f8128000000 65508 25204 25204 rw--- [ anon ] 00007f812bff9000 28 0 0 ----- [ anon ] 00007f812c000000 65508 24768 24768 rw--- [ anon ] 00007f812fff9000 28 0 0 ----- [ anon ] 00007f8130000000 65508 25532 25532 rw--- [ anon ] 00007f8133ff9000 28 0 0 ----- [ anon ] 00007f8134000000 65524 22764 22764 rw--- [ anon ] 00007f8137ffd000 12 0 0 ----- [ anon ] 00007f8138000000

I'm trying to locate where my memory has gone for a java process running in linux. Someone suggested I use pmap -x to see exactly what the memory is doing. The output is really long but basically a good portion of it is a repeat of this: 00007fbf75f6a000 1016 - - - rwx-- [ anon ] 00007fbf76068000 12 - - - ----- [ anon ] What exactly does this mean? Why do I have so many entries of this (4000+)? Anon blocks are "large" blocks allocated via malloc or mmap -- see the manpages. As such, they have nothing to do with the Java heap (other than the fact that the entire heap should be stored in just

I have a java application running on Java 8 inside a docker container. The process starts a Jetty 9 server and a web application is being deployed. The following JVM options are passed: -Xms768m -Xmx768m . Recently I noticed that the process consumes a lot of memory: $ ps aux 1 USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND app 1 0.1 48.9 5268992 2989492 ? Ssl Sep23 4:47 java -server ... $ pmap -x 1 Address Kbytes RSS Dirty Mode Mapping ... total kB 5280504 2994384 2980776 $ jcmd 1 VM.native_memory summary 1: Native Memory Tracking: Total: reserved=1378791KB, committed=1049931KB - Java