Long running C++ NIF segfaults

Hi, I built a NIF out of a well known C++ Dicom library called DCMTK. The purpouse of this NIF is to stay loaded for the whole life of my Elixir/Phoenix application, where it’s functions are called many times.

The module that loads this NIF is called from an Agent and I thought it stay there forever, but as it is segfaulting after using it for a while I’m starting to think it is removed from memory after some time…

Let me show my code:

defmodule Prueba3.ImageCache do                                                                                                                                                                                                              
  use Agent                                                                                                                                                                                                                                  
  def start_link(_opts) do                                                                                                                                                                                                                   
    Dcmtknif.initialize()                                                                                                                                                                                                                    
    Agent.start_link(fn -> %{} end, name: :imagecache)                                                                                                                                                                                       
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def get(key) do                                                                                                                                                                                                                            
    Agent.get(:imagecache, &Map.get(&1, key))                                                                                                                                                                                                
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def put(key, value) do                                                                                                                                                                                                                     
    Agent.update(:imagecache, &Map.put(&1, key, value))                                                                                                                                                                                      
  end                                                                                                                                                                                                                                        
end

defmodule Dcmtknif do                                                                                                                                                                                                                        
  @on_load :load_nifs                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def load_nifs do                                                                                                                                                                                                                           
    :erlang.load_nif('./ssr/libssr', 0)                                                                                                                                                                                                      
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _loadDicomFile(_dicomfile) do                                                                                                                                                                                                          
    raise "NIF _loadDicomFile/1 not implemented"                                                                                                                                                                                             
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _getTagValue(_dcmff, _group, _element) do                                                                                                                                                                                              
    raise "NIF getTagValue/1 not implemented"                                                                                                                                                                                                
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _getHeader(_dcmff) do                                                                                                                                                                                                                  
    raise "NIF getHeader/1 not implemented"                                                                                                                                                                                                  
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _getPNG(_dcmff) do                                                                                                                                                                                                                     
    raise "NIF getPNG/1 not implemented"                                                                                                                                                                                                     
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _setMinMaxWindow(_dcmff) do                                                                                                                                                                                                            
    raise "NIF setMinMaxWindow/1 not implemented"                                                                                                                                                                                            
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _createScaledImage(_dcmff, _width, _height, _interpolate, _aspect) do                                                                                                                                                                  
    raise "NIF createScaledImage/5 not implemented"                                                                                                                                                                                          
  end;                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                             
  def _initialize() do                                                                                                                                                                                                                       
    IO.puts("Dcmtknif.initialize()")                                                                                                                                                                                                         
    raise "NIF initialize/0 not implemented"                                                                                                                                                                                                 
  end                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
  def _finalize() do                                                                                                                                                                                                                         
    raise "NIF finalize/0 not implemented"                                                                                                                                                                                                   
  end   
  ... more functions
end

Do you see something wrong?