It&#39;s 32768 by default, you can read the value on your system in `/proc/sys/kernel/pid_max`.

And you can set the value higher on 64-bit systems (up to 2&lt;sup&gt;22&lt;/sup&gt; = 4,194,304) with:

    echo 4194304 &gt; /proc/sys/kernel/pid_max

Read more here:

[http://www.cs.wisc.edu/condor/condorg/linux_scalability.html (via archive.org)][1]


  [1]: http://web.archive.org/web/20111209081734/http://research.cs.wisc.edu/condor/condorg/linux_scalability.html

The maximum value of the PID in Linux is configurable. You can access it trough `/proc/sys/kernel/pid_max` file. This file (new in Linux 2.5) specifies the value at which PIDs wrap around (i.e., the value in this file is one greater than the maximum PID). The default value for this file, 32768, results in the same range of PIDs as on earlier kernels. The value in this file can be set to any value up to 2^22 (PID_MAX_LIMIT, approximately 4 million).

From the programming perspective, you have to use `pid_t` type to work with process ID. You can even access its min/max values using integer traits. Here is an example of doing that using C++ and Boost on Linux 2.6.X running on x86_64 platform:

    $ cat test.cpp 
    #include &lt;sys/types.h&gt;
    #include &lt;iostream&gt;
    #include &lt;boost/integer_traits.hpp&gt;
    
    using namespace std;
    
    int main ()
    {
        cout &lt;&lt; &quot;pid_t max = &quot; &lt;&lt; boost::integer_traits&lt;pid_t&gt;::const_max &lt;&lt; endl;
    }
    
    $ ./test 
    pid_t max = 2147483647



From the `proc(5)` man page:

&gt; `/proc/sys/kernel/pid_max` (since Linux 2.5.34)
&gt;
&gt; This file specifies the value at which PIDs wrap around (i.e., the value in this file is one greater than the  maximum  PID). PIDs greater than this value are not allocated; thus, the value in this file also acts as a system-wide limit on the total number of processes and threads.  The default value for this file, 32768,  results  in  the  same range  of  PIDs as on earlier kernels.  On 32-bit platforms, 32768 is the maximum value for pid_max.  On 64-bit systems, `pid_max` can be set to any value up to 2^22 (`PID_MAX_LIMIT`, approximately 4 million).

It seems that Ubuntu 20.04 has pushed the limit to the maximum (4194304):

    % cat /proc/sys/kernel/pid_max
    4194304



Anyone know how to check if a tag is on the git remote after the tag is pushed from the local?

It seems that the only way to do it is to fetch the remote. 

check if pushed tag is on the git remote

I&#39;ve got this piece of code:

    numbers = range(1, 50)

    for i in numbers:
        if i &lt; 20:
            numbers.remove(i)

    print(numbers)

but the result I&#39;m getting is:  
`[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]`

Of course, I&#39;m expecting the numbers below 20 to not appear in the results. Looks like I&#39;m doing something wrong with the remove.


Strange result when removing item from a list while iterating over it

I am porting an application from Tru64 to Linux and it uses PID_MAX defined in limits.h.
Linux doesn&#39;t have that define. 
How do I find PID_MAX in **c** without reading `/proc/sys/kernel/pid_max` by hand?
Is there a library?

Maximum PID in Linux

<p>I am porting an application from Tru64 to Linux and it uses PID_MAX defined in limits.h.
Linux doesn't have that define.
How do I find PID_MAX in <strong>c</strong> without reading <code>/proc/sys/kernel/pid_max</code> by hand?
Is there a library?</p>


When I try to build this code

    inline void f() {}
    
    int main()
    {
        f();
    }

using the command line

    gcc -std=c99 -o a a.c

I get a linker error (undefined reference to `f`).  The error vanishes if I use `static inline` or `extern inline` instead of just `inline`, or if I compile with `-O` (so the function is actually inlined).

This behaviour seems to be defined in paragraph 6.7.4 (6) of the C99 standard:
&gt; If all of the file scope declarations for a function in a translation unit include the `inline` function specifier without `extern`, then the definition in that translation unit is an inline definition. An inline definition does not provide an external definition for the function, and does not forbid an external definition in another translation unit. An inline definition provides an alternative to an external definition, which a translator may use to implement any call to the function in the same translation unit. It is unspecified whether a call to the function uses the inline definition or the external definition.

If I understand all this correctly, a compilation unit with a function defined `inline` as in the above example only compiles consistently if there is also an external function with the same name, and I never know if my own function or the external function is called.

Isn&#39;t this behaviour completely daft? Is it ever useful to define a function `inline` without `static` or `extern` in C99?  Am I missing something?

## Summary of answers

Of course I was missing something, and the behaviour isn&#39;t daft. :)

As [Nemo explains](https://stackoverflow.com/questions/6312597/is-inline-without-static-or-extern-ever-useful-in-c99/6312813#6312813), the idea is to put the *definition* of the function

    inline void f() {}

in the header file and only a *declaration*

    extern inline void f();

in the corresponding .c file.  Only the `extern` declaration triggers the generation of externally visible binary code.  And there is indeed no use of `inline` in a .c file -- it&#39;s only useful in headers.

As the [rationale of the C99 committee quoted in Jonathan&#39;s answer](https://stackoverflow.com/questions/6312597/is-inline-without-static-or-extern-ever-useful-in-c99/6312854#6312854) explicates, `inline` is all about compiler optimisations that require the definition of a function to be visible at the site of a call.  This can only be achieved by putting the definition in the header, and of course a definition in a header must not emit code every time it is seen by the compiler.  But since the compiler is not forced to actually inline a function, an external definition must exist somewhere.

Is &quot;inline&quot; without &quot;static&quot; or &quot;extern&quot; ever useful in C99?

I know that it improves readability and makes the program less error-prone, but how much does it improve the performance?

And on a side note, what&#39;s the major difference between a reference and a `const` pointer? I would assume they&#39;re stored in the memory differently, but how so?

Does const-correctness give the compiler more room for optimization?

I&#39;ve seen both full definitions of `struct`s in headers and just declarations—is there any advantage to one method over the other?

If it makes a difference, I usually typedef a struct like so in the `.h`

    typedef struct s s_t;

----

To be clear, the options are declaration in the header file and definition in the class, or both declaration and definition in the header file. Both should result in the same usability, even if one is by linkage, shouldn&#39;t they?

---

I see many almost duplicates, e.g. [here][1] but no exact matches. Please correct me if I&#39;m wrong in this regard.


  [1]: https://stackoverflow.com/questions/4136888/declaring-a-struct-in-h-file-and-implementing-in-c-file

Should struct definitions go in .h or .c file?

It seems that GCC and LLVM-Clang are using **handwritten recursive descent parsers**, and **not** machine generated, Bison-Flex based, bottom up parsing.

Could someone here please confirm that this is the case?
And if so, why do mainstream compiler frameworks use handwritten parsers?

**Update** : [interesting blog on this topic here ][2]


  [2]: http://blog.reverberate.org/2013/09/ll-and-lr-in-context-why-parsing-tools.html

Are GCC and Clang parsers really handwritten?

I have a question regarding using `intptr_t` vs. `long int`. I&#39;ve observed that incrementing memory addresses (e.g. via manual pointer arithmetic) differs by data type. For instance incrementing a char pointer adds 1 to the memory address, whereas incrementing an int pointer adds 4, 8 for a double, 16 for a long double, etc...

At first I did something like this:

	char myChar, *pChar;
	float myFloat, *pFloat;
	
	pChar = &amp;myChar;
	pFloat = &amp;myFloat;
	
	printf( &quot;pChar:  %d\n&quot;, ( int )pChar );
	printf( &quot;pFloat: %d\n&quot;, ( int )pFloat );
	
	pChar++;
	pFloat++;
	
	printf( &quot;and then after incrementing,:\n\n&quot; );
	printf( &quot;pChar:  %d\n&quot;, (int)pChar );
	printf( &quot;pFloat:	%d\n&quot;, (int)pFloat );

which compiled and executed just fine, but XCode gave me warnings for my typecasting: &quot;Cast from pointer to integer of different size.&quot;

After some googling and binging (is the latter a word yet?), I saw some people recommend using `intptr_t`:

    #include &lt;stdint.h&gt;
...
    
	printf( &quot;pChar:  %ld\n&quot;, ( intptr_t )pChar );
	printf( &quot;pFloat: %ld\n&quot;, ( intptr_t )pFloat );

which indeed resolves the errors. So, I thought, from now on, I should use `intptr_t` for typecasting pointers... But then after some fidgeting, I found that I could solve the problem by just replacing `int` with `long int`:

	printf( &quot;pChar:  %ld\n&quot;, ( long int )pChar );
	printf( &quot;pFloat: %ld\n&quot;, ( long int )pFloat );

So my question is, why is `intptr_t` useful, and when should it used? It seems superfluous in this instance. Clearly, the memory addresses for `myChar` and `myFloat` were just too big to fit in an `int`... so typecasting them to `long int`s solved the problem. 

Is it that sometimes memory addresses are too big for `long int` as well? Now that I think about it, I guess that&#39;s possible if you have &gt; 4GB of RAM, in which case memory addresses could exceed 2^32 - 1 (max value for unsigned long ints...) but C was created long before that was imaginable, right? Or were they that prescient?

Thanks!

Why / when to use `intptr_t` for type-casting in C?

I am running a script on a remote server. I ran the script in `screen`, however I need to stop it before it completes since I need to update the script. I can easily detach from `screen`, however, is there a way to kill a `screen` process?

How to stop a screen process in linux?

I&#39;m developing a web app that apparently is having problems in iOS devices. The problem is that I don&#39;t own an iOS device and I develop in Linux Ubuntu. I&#39;m looking for a way to emulate/simulate this OS in Linux (especially the browser), but haven&#39;t found anything.

So far, what I&#39;ve found is the iOS SDK&#39;s Simulator, but that is meant for the Mac. And also some emulator for Windows. Has anyone done this before?

Emulate/Simulate iOS in Linux

Rename all the files within a folder with prefix `&quot;Unix_&quot;` 

Suppose a folder has two files 

    a.txt
    b.pdf

then they both should be renamed from a single command to 

    Unix_a.txt
    Unix_b.pdf

Rename all files in a folder with a prefix in a single command

To me it&#39;s not clear what&#39;s the difference between the two Linux memory concepts : `buffer` and `cache`. I&#39;ve read through [this post][1] and it seems to me  that the difference between them is the expiration policy:

1. buffer&#39;s policy is first-in, first-out
2. cache&#39;s policy is Least Recently Used.

Am I right?

In particular, I&#39;m looking at the two commands: `free` and `vmstat`

    james@utopia:~$ vmstat -S M
    procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
    r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
    5  0      0    173     67    912    0    0    19    59   75 1087 24  4 71  1
    james@utopia:~$ free -m
                 total       used       free     shared    buffers     cached
    Mem:          2007       1834        172          0         67        914
    -/+ buffers/cache:        853       1153
    Swap:         2859          0       2859


  [1]: https://stackoverflow.com/questions/3192579/buffer-and-cache-difference

What is the difference between buffer and cache memory in Linux?

In Linux, how can I find all `*.js` files in a directory recursively?  The output should be an absolute path (like `/pub/home/user1/folder/jses/file.js`)



**this answer worked for me:**

    find $PWD -name &#39;*.js&#39; &gt; out.txt

It finds all *.js files, output absolute path, writes the results into out.txt.

How can I find all *.js file in directory recursively in Linux?

What&#39;s the logic behind calls like `getpid()` [returning a value of type][1] `pid_t` instead of an `unsigned int`? Or `int`? How does this help?

I&#39;m guessing this has to do with portability? Guaranteeing that `pid_t` is the same size across different platforms that may have different sizes of `int`s etc.?


  [1]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/getpid.html

Why does getpid() return pid_t instead of int?

How can I get an android application pid without using adb shell? Is there any API to get pid.
any help will be appreciated

How to get pid of android application without using adb shell?

I recently come across a file with the extension .pid and explored inside it but didn&#39;t find much. The documentation says:

&gt; A Pid-File is a file containing the process identification number (pid) that is stored in a well-defined location of the filesystem thus allowing other programs to find out the pid of a running script.

Can anyone shed more light on this, or guide me to details of what&#39;s contained in the pid file?

What is a .pid file and what does it contain?

Given the pid of a Linux process, I want to check, from a C program, if the process is still running.

Check if process exists given its pid

I have a query related to the implementation of threads in Linux.

Linux does not have an explicit thread support. In userspace, we might use an thread library (like NPTL) for creating threads. Now if we use NPTL it supports 1:1 mapping.

The kernel will use the `clone()` function to implement threads.

Suppose I have created 4 threads. Then it would mean that:

- There will be 4 `task_struct`. 
- Inside the `task_struct`, there will be provision of sharing resources as per the arguments to clone `(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND)`.

Now I have the following query:  

1. Will the 4 threads have the same PID? If someone can elaborate, how the PIDs are shared.  
2. How are the different threads identified; is there some TID (thread ID) concept?


Content Type	Original Author	Original Content on Stackoverflow
Question	Alexander Stolz	View Question on Stackoverflow
Solution 1 - C	Exos	View Answer on Stackoverflow
Solution 2 - C	user405725	View Answer on Stackoverflow
Solution 3 - C	Jonathon Reinhart	View Answer on Stackoverflow
Solution 4 - C	Antti Haapala -- Слава Україні	View Answer on Stackoverflow

Maximum PID in Linux

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Solution 3 - C

Solution 4 - C

Strange result when removing item from a list while iterating over it

check if pushed tag is on the git remote

Attributions