Questions & Help>Questions

Long running C++ NIF segfaults

#interoperability
leonardorame

leonardorame

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?

22 comments
#interoperability
2004 22

Showing Posts 1 to 10

whatyouhide

whatyouhide

Elixir Core Team

I’m not an expert in NIFs, but in general the VM yields execution to the NIF when you call it, so you’re really not supposed to have “long-running NIFs”. When you enter a NIF, the VM cannot do GC, context, switching, and so on anymore.

I think a common solution in a case like yours, where you have essentially an external program that needs to run continuously, is to use ports. You spawn the program you want to run and you let your Elixir application manage its lifetime. Then, you communicate with the spawned program through stdout.

Does that make sense?

1
Post #1
leonardorame

leonardorame OP

Hi @whatyouhide, I think I wrongly explained what this NIF does. With “long-running” I mean it has state (internal variables pointing to data structures that can be accessed from the parent Elixir process), please don’t confuse with long loops or heavy processes inside it.

Regarding your ports suggestion, I can do that, but it adds complexity on the C++ side and I’m trying to maintain that part as small as possible.

1
Post #2
leonardorame

leonardorame OP

This is where the program crashes, I call the image function ~100 times (not always the same number of times) then it crashes:

imagen
imagen1200×668 73 KB

0
Post #3
jhogberg

jhogberg

Erlang Core Team

I can assure you that the NIF hasn’t been unloaded. You would need to do that manually, and even then the VM takes great care not to pull the rug while anything references it.

I think I can see why it crashes though. What’s preventing image/2 from being called concurrently?

1
Post #4
leonardorame

leonardorame OP

Hi @jhogberg, nothing prevents that (in fact, it will be called concurrently at production), but as far as I understand the function createScaledImage_nif is thread safe (it receives the data that should use to work with by param, no global variables).

I added debug messages (std::cout) everywhere in the createScaledImage_nif, and found the app crashes just before entering into that function.

0
Post #5
jhogberg

jhogberg

Erlang Core Team

Imagine that you get several concurrent calls to image/2 with the same sopinstanceuid.

Isn’t there then a pretty good chance that they all end up calling createScaledImage_nif, setMinMaxWindow_nif, and getPNG_nif with the same resource?

Also, would you care to share the code for getPNG_nif?

1
Post #6
leonardorame

leonardorame OP

Yes, the program should allow concurrently call createScaledImage_nif, it has a pointer to a resource with the original image, then this function returns a scaled version of it, never overwriting the original.

Here’s the getPNG_nif function:

ERL_NIF_TERM getPNG_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])                                                                                                                                                                 
{                                                                                                                                                                                                                                            
    dcmfileformat_t *ff_res;                                                                                                                                                                                                                 
                                                                                                                                                                                                                                             
    if(!enif_get_resource(env, argv[0], ff_res_t, (void **) &ff_res)) {                                                                                                                                                                      
        return enif_make_badarg(env);                                                                                                                                                                                                        
    };                                                                                                                                                                                                                                       
    DcmDataset *ds = ff_res->_ff->getDataset();                                                                                                                                                                                              
                                                                                                                                                                                                                                             
    std::vector<ui8> out;                                                                                                                                                                                                                    
    writePNGtoMemory(ff_res->_dicomimage, &out, 0);                                                                                                                                                                                          
    ErlNifBinary bin;                                                                                                                                                                                                                        
    enif_alloc_binary(out.size(), &bin);                                                                                                                                                                                                     
    memcpy(bin.data, out.data(), out.size());                                                                                                                                                                                                
    return enif_make_binary(env, &bin);                                                                                                                                                                                                      
    return enif_make_atom(env, "ok");                                                                                                                                                                                                        
}
0
Post #7
leonardorame

leonardorame OP

I commented the block that uses the cached image (lines 27 to 38) and the program didn’t segfaults. It looks like something is filling the cachedDcmFF variable with garbage:

 22   def image(conn, params) do                                                                                                                                                                                                             
 23     sopinstanceuid = params["sopinstanceuid"]                                                                                                                                                                                            
 24     {width, ""} = Integer.parse(params["width"])                                                                                                                                                                                         
 25     {height, ""} = Integer.parse(params["height"])                                                                                                                                                                                       
 26     cachedDcmFF = ImageCache.get(sopinstanceuid)                                                                                                                                                                                         
 27     if cachedDcmFF do                                                                                                                                                                                                                    
 28       IO.puts("====> CACHED! <====")                                                                                                                                                                                                     
 29       Dcmtknif.createScaledImage(cachedDcmFF, width, height, 0, 0);                                                                                                                                                                      
 30       IO.puts("====> createScaledImage <====")                                                                                                                                                                                           
 31       Dcmtknif.setMinMaxWindow(cachedDcmFF)                                                                                                                                                                                              
 32       IO.puts("====> setMinMaxWindow <====")                                                                                                                                                                                             
 33       pngimage = Dcmtknif.getPNG(cachedDcmFF)                                                                                                                                                                                            
 34       IO.puts("====> getPNG <====")                                                                                                                                                                                                      
 35       conn                                                                                                                                                                                                                               
 36       |> put_resp_content_type("image/png")                                                                                                                                                                                              
 37       |> send_resp(200, pngimage)                                                                                                                                                                                                        
 38     else                                                                                                                                                                                                                                 
 39       im = ApiController.image(sopinstanceuid)                                                                                                                                                                                           
 40       IO.puts(im.imagepath)                                                                                                                                                                                                              
 41       if File.exists?(im.imagepath) do                                                                                                                                                                                                   
 42         IO.puts("====> NOT CACHED, LOADING FROM FILE <====")                                                                                                                                                                             
 43         dicomfile = im.imagepath                                                                                                                                                                                                         
 44         dcmff = Dcmtknif.load(dicomfile)                                                                                                                                                                                                 
 45         ImageCache.put(sopinstanceuid, dcmff)                                                                                                                                                                                            
 46         Dcmtknif.createScaledImage(dcmff, width, height, 0, 0);                                                                                                                                                                          
 47         Dcmtknif.setMinMaxWindow(dcmff)                                                                                                                                                                                                  
 48         pngimage = Dcmtknif.getPNG(dcmff)                                                                                                                                                                                                
 49         conn                                                                                                                                                                                                                             
 50         |> put_resp_content_type("image/png")                                                                                                                                                                                            
 51         |> send_resp(200, pngimage)                                                                                                                                                                                                      
 52       else                                                                                                                                                                                                                               
 53         conn                                                                                                                                                                                                                             
 54         |> send_resp(404, "File not found")                                                                                                                                                                                              
 55       end                                                                                                                                                                                                                                
 56     end                                                                                                                                                                                                                                  
 57   end
0
Post #8
jhogberg

jhogberg

Erlang Core Team

You are overwriting ff_res->_dicomimage however, so you’ll at the very least be leaking memory.

Please share what happens to ff_res->_dicomimage inside writePNGtoMemory, is there a delete ff_res->_dicomimage or similar in there?

Concurrent accesses would do that.

0
Post #9
leonardorame

leonardorame OP

Maybe this is the culpit:

dcmff = Dcmtknif.load(dicomfile)

Elixir:

def load(dicomfile) do                                                                                                                                                                                                                     
  _loadDicomFile(String.to_charlist(dicomfile))                                                                                                                                                                                            
end

C++

DcmFileFormat * loadDicomFile(const char * dicomfile){                                                                                                                                                                                       
  DcmFileFormat *ff = new DcmFileFormat();                                                                                                                                                                                                   
  if (ff->loadFile(dicomfile).good())                                                                                                                                                                                                        
  {                                                                                                                                                                                                                                          
    return ff;                                                                                                                                                                                                                               
  }                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                             
  return NULL;                                                                                                                                                                                                                               
}

ERL_NIF_TERM loadDicomFile_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])                                                                                                                                                          
{                                                                                                                                                                                                                                            
  char dicomfile[MAXBUFLEN];                                                                                                                                                                                                                 
  enif_get_string(env, argv[0], dicomfile, sizeof(dicomfile), ERL_NIF_LATIN1);                                                                                                                                                               
                                                                                                                                                                                                                                             
  DcmFileFormat *ff = loadDicomFile(dicomfile);                                                                                                                                                                                              
                                                                                                                                                                                                                                             
  // Let's allocate the memory for a DcmFileFormat * pointer                                                                                                                                                                                 
  dcmfileformat_t *ff_res = (dcmfileformat_t *)enif_alloc_resource(ff_res_t, sizeof(dcmfileformat_t));                                                                                                                                       
  if (ff_res == NULL){                                                                                                                                                                                                                       
    std::cout << "ff_res = NULL" << std::endl;                                                                                                                                                                                               
    enif_make_badarg(env);                                                                                                                                                                                                                   
  }                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                             
  ff_res->_ff = ff;                                                                                                                                                                                                                          
                                                                                                                                                                                                                                             
  // We can now make the Erlang term that holds the resource                                                                                                                                                                                 
  ERL_NIF_TERM term = enif_make_resource(env, ff_res);                                                                                                                                                                                       
                                                                                                                                                                                                                                             
  // ...and release the resource so that it will be freed when Erlang garbage collects                                                                                                                                                       
  enif_release_resource(ff_res);                                                                                                                                                                                                             
                                                                                                                                                                                                                                             
  return term;                                                                                                                                                                                                                               
}
0
Post #10

Where Next? Top

View thread on forum (has 22 replies!)
interoperability
Home Questions & Help>Questions
7 1778 22
Last post
REPLY VIEW THREAD WITH 22 POSTS

Trending in Questions Top

katta
Questions & Help>Questions

Phoenix Ecto realistic benchmarks
I having some trouble figuring out if I have set myself too strict of standards for my production server. Currently I can handle 75% of r...
/phoenix#ecto#troubleshooting
2 1515 11
New
brecabral
Questions & Help>Questions

Scoped Routes section of the Phoenix guides refers to a problem without explaining what it is ("but there is a problem")
Documentation While reading the Scoped Routes section, I noticed that the documentation currently refers to a problem without explainin...
/phoenix
6 829 4
New
achenet
Questions & Help>Questions

No Tailwind binary for FreeBSD
Hello, I’m trying to build a basic Phoenix web-app, and I’d like to use Tailwind. However, when I launch mix phx.server, I get an error...
/phoenix#freebsd#tailwindcss#tailwind
11 1073 14
New
kpanic
Questions & Help>Questions

"Mentoring" match maker? maybe MVP
Hi everyone, I am toying with the idea of building a “match maker” for giving personal help to people that wants to start coding. I sta...
#helpers#programming
8 940 4
New
asweet-confluent
Questions & Help>Questions

Why is Logger's default level :debug?
I recently noticed that Elixir’s Logger defaults its primary log level to :debug when no :logger, :level application configuration is pre...
#logging#logger
13 504 10
New
Cxx-mlr
Questions & Help>Questions

Using try/catch with update_in/3
I’m working on a small exercise involving update_in/3, and I came up with this solution: data = %{ name: "Periodic Table", category:...
#learning-elixir
9 273 12
New
ChrisAmelia
Questions & Help>Questions

Need help understanding order of function calls from Phoenix auth
I’ve got trouble wrapping my head around the order in which functions are called in this snippet (from Phoenix’s authentication): toke...
/phoenix#learning-elixir
0 76 2
New

Other Trending Topics Top

GenericJam
News>Announcing

Mob - Native BEAM / Elixir on Native Mobile
Edit: 2026 May 15 - This post is archived. Mob is alive!! Main docs: mob v0.7.11 — Documentation A bit of explanation for the slightly c...
/mob#library#beam#mobile#liveview#react-native#mobile-app#mobile-development
259 8396 111
New
JesseHerrick
News>Announcing

Dexter - A fast, full-featured Elixir LSP optimized for large codebases
Hey, I’m Jesse and I’m the main contributor behind Dexter, a full-featured, lightning-fast Elixir LSP optimized for large codebases. It s...
#library#lsp#dexter
187 6988 64
New
mudasobwa
Chat & Discussions>Discussions

Cure - a new language compiled to BEAM
I am happy to introduce the very α version of the new programming language compiled to BEAM. Welcome Cure. It has literally three kille...
#static-types#type-checking#types#fsm
171 6315 70
New
garrison
News>Announcing

Hobbes - a low-level distributed database for the Elixir programming language
Hobbes is a low-level distributed database for the Elixir programming language. Hobbes provides a simple, safe, and scalable storage lay...
#library#database#distributed#hobbes
306 6242 88
New
mhanberg
Chat & Discussions>Discussions

Expert LSP is now available!
Hi everyone! The first release candidate for the Expert language server project is now available! We’ve published a press release detai...
#lsp#expert
220 4348 38
New
budgie
Chat & Discussions>Discussions

I genuinely hate programming now
A little off-topic, but I feel like people here have a good head on their shoulders. I used to be quite good at making software. Was luc...
#ai#career#rant
435 3543 108
New
Back to top

Questions & Help>Questions

Questions Questions ❯

Latest on Elixir Forum

Elixir Forum ❯

Sponsor Spotlight

Manning

Master modern tools, write cleaner code, and tackle real-world challenges with Manning books, videos, and courses. Start building today.

Our Sponsors

Dashbit

Build Elixir applications with speed and confidence.

EEF

Supporting innovation across the BEAM ecosystem.

Coders51

We build reliable cloud platforms for business-critical systems.

AppSignal

Catch errors, track performance, monitor hosts and more.

Code Sync

Elixir, Erlang & BEAM conferences from Code Sync - join us in 2026!

Pragmatic Bookshelf

Practical resources that improve the lives of professional developers.

Defacto

Bringing learning, work and compliance together since 1987.

Potions

The deployment platform built for Elixir: PaaS ease, VPS control.

Software Mansion

The team behind Membrane, Popcorn, LiveDebugger. Available for hire.

Pragmatic Studio

Courses that'll move you from confusion to "Aha, now I get it!"

View all our sponsors ❯

Categories:

Sub Categories:

Forums

Popular Tags

Our Sponsors

Dashbit

Build Elixir applications with speed and confidence.

EEF

Supporting innovation across the BEAM ecosystem.

Coders51

We build reliable cloud platforms for business-critical systems.

AppSignal

Catch errors, track performance, monitor hosts and more.

Code Sync

Elixir, Erlang & BEAM conferences from Code Sync - join us in 2026!

Pragmatic Bookshelf

Practical resources that improve the lives of professional developers.

Defacto

Bringing learning, work and compliance together since 1987.

Potions

The deployment platform built for Elixir: PaaS ease, VPS control.

Software Mansion

The team behind Membrane, Popcorn, LiveDebugger. Available for hire.

Pragmatic Studio

Courses that'll move you from confusion to "Aha, now I get it!"

View all our sponsors ❯

We're in Beta

About us Mission Statement

Options

Thread Display Mode




Thread Preview

Skip Thread Previews