1

I'm using a library which creates a pthread using the default stack size of 8MB. Is it possible to programatically reduce the stack size of the thread the library creates? I tried using setrlimit(RLIMIT_STACK...) inside my main() function, but that doesn't seem to have any effect. ulimit -s seems to do the job, but I don't want to set the stack size before my program is executed.

Any ideas what I can do? Thanks

Update 1: Seems like I'm going to give up on being able to set the stack size using setrlimit(RLIMIT_STACK,...). I checked the resident memory and found it's a lot less than the virtual memory. That's a good enough reason for me to give up on trying to limit the stack size.

Improve this question
6
  • What was your setrlimit call and what was the return value? Commented Jul 29, 2014 at 16:04
  • Is it pthreads library? if so, you could use pthread_attr_setstacksize(). Commented Jul 29, 2014 at 16:04
  • @BlueMoon, I can't use pthread_attr_setstacksize() because the pthread is created in the library I'm using. @mafso, setrlimit returned 0. BTW, I set rlim_cur and rlim_max to 1MB, but it's as if the created thread is still using a stack size of 8MB. Commented Jul 29, 2014 at 16:14
  • 1
    I see. So it's a wrapper to pthreads (or some other library). Why doesn't it provide an interface to set the attributes for threads? Btw, what are you trying to achieve by reducing stack size? Are you setting setrlimit before the threads were created? Commented Jul 29, 2014 at 16:32
  • Can't answer why an option to set the thread attributes wasn't provided. I'm just trying to reduce overall memory usage, especially since I'm running on a system with 64MB of memory and no swap. Yes, I'm setting rlimit before the threads were created. setrlimit is one of the first things I do in main() Commented Jul 29, 2014 at 16:44

2 Answers 2

Reset to default
1

I think you are out of luck. If the library you are using does not provide a way to set the stack limit, then you can't change it after the thread has been created. setrlimit and shell limits effects the main thread's stack.

Threads are created within the processes memory space so their stacks are allocated when the threads are created. On Unix I believe the stack will be mapped to RAM on demand, so you may not actually use 8 Megs of RAM if you don't need it (virtual vs resident memory).

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

There are a couple aspects to answering this question.

First, as stated in the comments, pthread_attr_setstacksize is The Right Way to do this. If the library calling pthread_create doesn't have a way to let you do this, fixing the library would be the ideal solution. If the thread is purely internal to the library (not calling code from the calling application) it really should set its own preference for the stack size based on something like PTHREAD_STACK_MIN + ITS_OWN_NEEDS. If it's calling back to your code, it should let you request how much stack space you need.

Second, as an implementation detail, glibc uses the stack limit from setrlimit/ulimit to derive the stack size for threads created by pthread_create. You can perhaps influence the size this way, but it's not portable, and as you've found, not reliable even there (it's not working when you call setrlimit from within the process itself). It's possible that glibc only probes the limit once when the relevant code is first initialized, so I would try moving the setrlimit call as early as possible in main to see if this helps.

Finally, the stack size for threads may not even be relevant to your application. Even if the stack size is 8MB, only the pages which have actually been modified (probably 4k or at most 8k unless you have big arrays on the stack) are actually using physical memory. The rest is just tying up virtual address space (of which you always have at least 2-3 GB) and possibly commit charge. By default, Linux enables overcommit, so commit charge will not be strictly enforced, and therefore the fact that glibc is requesting too much may not even matter. You could make the overcommit checking even less strict by writing a 1 to /proc/sys/vm/overcommit_memory, but this will cause you to loose information about when you're "running out of memory" and make your program crash instead. On such a constrained system you may prefer even stricter overcommit accounting, but then you have to fix the thread stack size problem...

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.