def someOtherHotSpotCallable():
    # Statistic profiler
    prof = pprofile.StatisticalProfile()
    with prof(
        period=0.001, # Sample every 1ms
        single=True, # Only sample current thread
    ):
        # Code to profile
    prof.print_stats()

❯ make
clang++ -std=c++14 -g -ffast-math -fno-builtin-malloc -O3 -DNDEBUG  -D'CUSTOM_PREFIX(x)=xx##x' -I/usr/include/nptl -fno-builtin-malloc -pipe -fPIC -I. -I./include -IHeap-Layers -IHeap-Layers/utility -D_REENTRANT=1 -shared libscalene.cpp Heap-Layers/wrappers/gnuwrapper.cpp -Bsymbolic -o libscalene.so -ldl -lpthread
Heap-Layers/wrappers/gnuwrapper.cpp:55:9: warning: 'CUSTOM_PREFIX' macro redefined [-Wmacro-redefined]
#define CUSTOM_PREFIX(x) custom##x
        ^
<command line>:2:9: note: previous definition is here
#define CUSTOM_PREFIX(x) xx##x
        ^
1 warning generated.

~/projects/scalene fix_usage*
❯ LD_PRELOAD=$PWD/libscalene.so PYTHONMALLOC=malloc python -m scalene benchmarks/julia1_nopil.py
Length of x: 2000
Total elements: 4000000
Scalene: Memory exhausted: sz = 32
[1]    1376452 segmentation fault (core dumped)  LD_PRELOAD=$PWD/libscalene.so PYTHONMALLOC=malloc python -m scalene

test2.py: % of CPU time = 100.00% out of   3.59s.
  	 |     CPU % |     CPU % | Avg memory  | Memory      |
  Line	 |  (Python) |  (native) | growth (MB) | usage (%)   | [test2.py]
--------------------------------------------------------------------------------
     1	 |           |           |             |             | import numpy as np
     2	 |           |           |             |             |
     3	 |     0.30% |    48.40% |         -80 |       1.03% | x = np.array(range(10**7))
     4	 |     0.59% |    50.72% |           0 |      98.97% | np.array(np.random.uniform(0, 100, size=10**8))
     5	 |           |           |             |             |

Added fast memcpy implementation.

# Some Log....
Line #    Mem usage    Increment   Line Contents
================================================
    35    237.4 MiB    237.4 MiB   @profile()
    36                             def linearRegressionfit(Xt,Yt,Xts,Yts):
    37    237.4 MiB      0.0 MiB       lr=LinearRegression()
    38    241.0 MiB      3.5 MiB       model=lr.fit(Xt,Yt)
    39    241.0 MiB      0.0 MiB       predict=lr.predict(Xts)
    40                             
    41    241.0 MiB      0.0 MiB       print("train Accuracy",lr.score(Xt,Yt))
    42    241.0 MiB      0.0 MiB       print("test Accuracy",lr.score(Xts,Yts))

# More log.....

Scalene: Program did not run for long enough to profile.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestRegressor
import numpy as np

from memory_profiler import profile
#fp=open('memory_profile.log','w+')
@profile()
def import_data():
    data=pd.read_csv("kc_house_data.csv")
    data=data.drop(["id","date"],axis=1)
    data["sqft_above"].fillna(1788.39,inplace=True)
    return data
    #data.describe()

@profile()
def parse_data(data):
    Y=data["price"].va[What actually happens]lues
    Y=np.log(Y)
    features=data.columns
    X1=list(set(features)-set(["price"]))
    X=data[X1].values
    ss=StandardScaler()
    X=ss.fit_transform(X)
    return X,Y

@profile()
def linearRegressionfit(Xt,Yt,Xts,Yts):
    lr=LinearRegression()
    model=lr.fit(Xt,Yt)
    predict=lr.predict(Xts)

    print("train Accuracy",lr.score(Xt,Yt))
    print("test Accuracy",lr.score(Xts,Yts))

@profile()
def randForestRegressorfit(Xt,Yt,Xts,Yts):
    regr = RandomForestRegressor(n_estimators=100,max_features='auto',max_depth=80 ,min_samples_leaf=1
                                 ,min_samples_split=2,random_state=0)
    model=regr.fit(Xt,Yt)
    predict=regr.predict(Xts)
    print("train Accuracy : ",regr.score(Xt,Yt))
    print("test Accuracy : ",regr.score(Xts,Yts))


if __name__ == '__main__':
    data = import_data()
    X, Y = parse_data(data)
    Xt,Xts,Yt,Yts=train_test_split(X,Y,test_size=0.4,random_state=0)
    linearRegressionfit(Xt,Yt,Xts,Yts)

    randForestRegressorfit(Xt,Yt,Xts,Yts)
    linearRegressionfit(Xt,Yt,Xts,Yts)

% pip install pyperformance
% git clone https://github.com/python/pyperformance.git
% cd pyperformance/pyperformance/benchmarks
% scalene bm_pyflate.py 
Scalene: could not find input file.
Scalene: Program did not run for long enough to profile.

import tensorflow as tf
mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

predictions = model(x_train[:1]).numpy()
print("predictions", predictions)

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test,  y_test, verbose=2)

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
2020-07-11 22:48:31.990954: I tensorflow/core/platform/cpu_feature_guard.cc:143] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2020-07-11 22:48:32.014027: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7fd41b7a03b0 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2020-07-11 22:48:32.014048: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version
predictions [[-0.27964824  0.78479844 -0.39851144  0.14115062  0.09268872 -0.1322664
   0.04173797 -0.04924813 -0.10641377  0.1781306 ]]
Epoch 1/5
1875/1875 [==============================] - 1s 717us/step - loss: 0.3024 - accuracy: 0.9126
Epoch 2/5
1875/1875 [==============================] - 1s 714us/step - loss: 0.1416 - accuracy: 0.9576
Epoch 3/5
1875/1875 [==============================] - 1s 708us/step - loss: 0.1070 - accuracy: 0.9674
Epoch 4/5
1875/1875 [==============================] - 1s 699us/step - loss: 0.0881 - accuracy: 0.9731
Epoch 5/5
1875/1875 [==============================] - 1s 708us/step - loss: 0.0749 - accuracy: 0.9766
313/313 - 0s - loss: 0.0748 - accuracy: 0.9766

(base) ➜  scalene git:(master) ✗ scalene ./test/tf-keras.py 
2020-07-11 22:49:21.339374: I tensorflow/core/platform/cpu_feature_guard.cc:143] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2020-07-11 22:49:21.370759: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x11b1b4630 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2020-07-11 22:49:21.370778: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version
predictions [[-0.1633205  -0.22706667  0.58521605  0.357562   -0.51517636  0.45471746
  -0.10387493  0.41047204 -0.26368517  0.10465179]]
Epoch 1/5
/usr/local/bin/scalene: line 3: 24592 Segmentation fault: 11  DYLD_INSERT_LIBRARIES=/usr/local/Cellar/libscalene/HEAD-a49f5ca/lib/libscalene.dylib PYTHONMALLOC=malloc python3 -m scalene "$@" 

# -*- coding: utf-8 -*-
import random
import torch


class DynamicNet(torch.nn.Module):
    def __init__(self, D_in, H, D_out):
        """
        In the constructor we construct three nn.Linear instances that we will use
        in the forward pass.
        """
        super(DynamicNet, self).__init__()
        self.input_linear = torch.nn.Linear(D_in, H)
        self.middle_linear = torch.nn.Linear(H, H)
        self.output_linear = torch.nn.Linear(H, D_out)

    def forward(self, x):
        """
        For the forward pass of the model, we randomly choose either 0, 1, 2, or 3
        and reuse the middle_linear Module that many times to compute hidden layer
        representations.

        Since each forward pass builds a dynamic computation graph, we can use normal
        Python control-flow operators like loops or conditional statements when
        defining the forward pass of the model.

        Here we also see that it is perfectly safe to reuse the same Module many
        times when defining a computational graph. This is a big improvement from Lua
        Torch, where each Module could be used only once.
        """
        h_relu = self.input_linear(x).clamp(min=0)
        for _ in range(random.randint(0, 3)):
            h_relu = self.middle_linear(h_relu).clamp(min=0)
        y_pred = self.output_linear(h_relu)
        return y_pred


# N is batch size; D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10

# Create random Tensors to hold inputs and outputs
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

# Construct our model by instantiating the class defined above
model = DynamicNet(D_in, H, D_out)

# Construct our loss function and an Optimizer. Training this strange model with
# vanilla stochastic gradient descent is tough, so we use momentum
criterion = torch.nn.MSELoss(reduction='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)
for t in range(500):
    # Forward pass: Compute predicted y by passing x to the model
    y_pred = model(x)

    # Compute and print loss
    loss = criterion(y_pred, y)
    if t % 100 == 99:
        print(t, loss.item())

    # Zero gradients, perform a backward pass, and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

(base) ➜  scalene git:(master) ✗ python ./test/torch-dynamic-model.py 
99 38.210121154785156
199 0.7706254720687866
299 2.6024699211120605
399 0.5532416701316833
499 0.3656597137451172

(base) ➜  scalene git:(master) ✗ scalene test/torch-dynamic-model.py 
/usr/local/bin/scalene: line 3: 23709 Segmentation fault: 11  DYLD_INSERT_LIBRARIES=/usr/local/Cellar/libscalene/HEAD-a49f5ca/lib/libscalene.dylib PYTHONMALLOC=malloc python3 -m scalene "$@"

slow.py: % of CPU time = 100.00% out of   0.35s.
  	 |     CPU % |     CPU % |   
  Line	 |  (Python) |  (native) |  [slow.py]
--------------------------------------------------------------------------------
     1	 |           |           | def run(i):
     2	 |           |           |     s = 0
     3	 |           |           |     for j in range(i):
     4	 |    11.69% |           |         for k in range(j):
     5	 |    87.68% |     1.80% |             s +=1
     6	 |           |           |     return s

$ python -m scalene issue.py

File "/home/poh/.pyenv/versions/3.7.2/lib/python3.7/site-packages/attr/_make.py", line 245, in _make_attr_tuple_class
    eval(compile("\n".join(attr_class_template), "", "exec"), globs)
  File "", line 1, in <module>
  File "/home/poh/.pyenv/versions/3.7.2/lib/python3.7/site-packages/scalene/scalene.py", line 91, in cpu_signal_handler
    if not scalene.should_trace(fname):
  File "/home/poh/.pyenv/versions/3.7.2/lib/python3.7/site-packages/scalene/scalene.py", line 129, in should_trace
    if filename[0] == '<':
IndexError: string index out of range

$ nm --demangle -D ~/software/scalene/libscalene.so  | grep -v ' [uUwW] '
0000000000002ec0 T customaligned_alloc
0000000000002ca0 T customcalloc
0000000000002c90 T customcfree
0000000000002c80 T customfree
0000000000003020 T customgetcwd
0000000000003100 T custommallinfo
0000000000002c70 T custommalloc
0000000000002f60 T custommalloc_good_size
0000000000002f50 T custommalloc_usable_size
00000000000030b0 T custommallopt
0000000000002d90 T custommemalign
0000000000002e20 T customposix_memalign
0000000000003230 T custompvalloc
0000000000002cf0 T customrealloc
0000000000003290 T customrecalloc
0000000000002fe0 T customstrdup
0000000000002f90 T customstrndup
00000000000031e0 T customvalloc
0000000000006120 D __malloc_initialize_hook
0000000000002480 T xxfree
00000000000025a0 T xxfree_sized
00000000000023d0 T xxmalloc
00000000000030e0 T xxmalloc_GET_STATE
0000000000002770 T xxmalloc_lock
00000000000030f0 T xxmalloc_SET_STATE
00000000000030d0 T xxmalloc_STATS
00000000000030c0 T xxmalloc_TRIM
0000000000002780 T xxmalloc_unlock
0000000000002760 T xxmalloc_usable_size
0000000000002340 T getTheCustomHeap()
00000000000031d0 T operator delete[](void*)
0000000000003160 T operator delete(void*)
0000000000003180 T operator new[](unsigned long)
00000000000031c0 T operator new[](unsigned long, std::nothrow_t const&)
0000000000003120 T operator new(unsigned long)
0000000000003170 T operator new(unsigned long, std::nothrow_t const&)
0000000000006278 V RepoSource<4096>::getSource()::head

import os

print(__file__)
print(os.path.realpath(__file__))

$ python3 scripts/foo.py
scripts/foo.py
/tmp/scripts/foo.py   # <- as expected
$ python3 -m scalene scripts/foo.py
scripts/foo.py
/tmp/scripts/scripts/foo.py  # <- the extra /scripts is problematic

(base) alberto@serenity:~$ python -m scalene scalene/test/testme.py
Scalene: An exception of type ItimerError occurred. Arguments:
(22, 'Invalid argument')
Traceback (most recent call last):
  File "/home/alberto/miniconda3/lib/python3.7/site-packages/scalene/scalene.py", line 712, in main
    profiler.start()
  File "/home/alberto/miniconda3/lib/python3.7/site-packages/scalene/scalene.py", line 488, in start
    Scalene.enable_signals()
  File "/home/alberto/miniconda3/lib/python3.7/site-packages/scalene/scalene.py", line 196, in enable_signals
    signal.setitimer(Scalene.cpu_timer_signal, Scalene.mean_signal_interval, Scalene.mean_signal_interval)
signal.ItimerError: [Errno 22] Invalid argument

Error in atexit._run_exitfuncs:
Traceback (most recent call last):
  File "/home/alberto/miniconda3/lib/python3.7/site-packages/scalene/scalene.py", line 656, in exit_handler
    Scalene.disable_signals()
  File "/home/alberto/miniconda3/lib/python3.7/site-packages/scalene/scalene.py", line 648, in disable_signals
    signal.setitimer(Scalene.cpu_timer_signal, 0)
signal.ItimerError: [Errno 22] Invalid argument

#!/usr/bin/env sh

DYLD_INSERT_LIBRARIES=/usr/local/Cellar/libscalene/HEAD-e3cdcb7/lib/libscalene.dylib PYTHONMALLOC=malloc python -m scalene "$@"

$ brew tap antonalekseev/tap
$ brew install --head libscalene

Core was generated by `python -m scalene conv3d_run.py'.
Program terminated with signal SIGSEGV, Segmentation fault.
#0  0x000055d24e6b8b46 in PyNumber_InPlaceOr ()
Missing separate debuginfos, use: zypper install glibc-debuginfo-2.22-62.22.5.x86_64

Usage: cProfile.py [-o output_file_path] [-s sort] [-m module | scriptfile] [arg] ...

orchestrator_1  | Fatal Python error: Unreachable C code path reached
orchestrator_1  | Python runtime state: initialized
orchestrator_1  | 
orchestrator_1  | Thread 0x00007fecf6fc0700 (most recent call first):
orchestrator_1  |   File "/pyenv/test/httplib2/__init__.py", line 194 in _build_ssl_context
orchestrator_1  |   File "/pyenv/test/httplib2/__init__.py", line 1238 in __init__
orchestrator_1  |   File "/pyenv/test/httplib2/__init__.py", line 1758 in request
orchestrator_1  |   File "/py/pyenv/venv_run.sh: line 24:    12 Segmentation fault      "$@"

                                         target.py: % of CPU time = 100.00% out of   4.38s.                                         
       ╷        ╷        ╷                                                                                                          
  Line │CPU %   │CPU %   │                                                                                                          
       │Python  │native  │target.py                                                                                                 
╺━━━━━━┿━━━━━━━━┿━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╸
     1 │   7.1% │  17.2% │import numpy as np                                                                                        
     2 │        │        │                                                                                                          
     3 │        │        │def main():                                                                                               
     4 │   0.2% │  38.0% │    x = np.array(range(10**7))                                                                            
     5 │   0.5% │  37.0% │    y = np.array(np.random.uniform(0, 100, size=(10**8)))                                                 
     6 │        │        │                                                                                                          
     7 │        │        │main()                                                                                                    

^CTraceback (most recent call last):
  File "/home/edo/.local/bin/scalene", line 5, in <module>
    from scalene.__main__ import main
  File "/home/edo/.local/lib/python3.6/site-packages/scalene/__main__.py", line 1, in <module>
    from scalene import scalene
  File "/home/edo/.local/lib/python3.6/site-packages/scalene/scalene.py", line 261, in <module>
    result = subprocess.run(args)
  File "/usr/lib/python3.6/subprocess.py", line 425, in run
    stdout, stderr = process.communicate(input, timeout=timeout)
  File "/usr/lib/python3.6/subprocess.py", line 855, in communicate
    self.wait()
  File "/usr/lib/python3.6/subprocess.py", line 1477, in wait
    (pid, sts) = self._try_wait(0)
  File "/usr/lib/python3.6/subprocess.py", line 1424, in _try_wait
    (pid, sts) = os.waitpid(self.pid, wait_flags)
KeyboardInterrupt