mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

common/fdlimit: Move fdlimit files to separate package (#15850)

Browse Source 
* common/fdlimit: Move fdlimit files to separate package

When go-ethereum is used as a library the calling program need to set
the FD limit.

This commit extract fdlimit files to a separate package so it can be
used outside of go-ethereum.

* common/fdlimit: Remove FdLimit from functions signature

* common/fdlimit: Rename fdlimit functions
pull/15863/head
Ricardo Domingos 7 years ago committed by Péter Szilágyi
parent 023769d9d4
commit 56152b31ac
5 changed files with 31 additions and 30 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 5
      cmd/utils/flags.go
  2. 14
      common/fdlimit/fdlimit_freebsd.go
  3. 10
      common/fdlimit/fdlimit_test.go
  4. 14
      common/fdlimit/fdlimit_unix.go
  5. 18
      common/fdlimit/fdlimit_windows.go

5
cmd/utils/flags.go
Unescape View File

@ -31,6 +31,7 @@ import (
"github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/accounts/keystore"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/fdlimit"
"github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/clique" "github.com/ethereum/go-ethereum/consensus/clique"
"github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/consensus/ethash"
@ -721,10 +722,10 @@ func setIPC(ctx *cli.Context, cfg *node.Config) {
// makeDatabaseHandles raises out the number of allowed file handles per process // makeDatabaseHandles raises out the number of allowed file handles per process
// for Geth and returns half of the allowance to assign to the database. // for Geth and returns half of the allowance to assign to the database.
func makeDatabaseHandles() int { func makeDatabaseHandles() int {
if err := raiseFdLimit(2048); err != nil { if err := fdlimit.Raise(2048); err != nil {
Fatalf("Failed to raise file descriptor allowance: %v", err) Fatalf("Failed to raise file descriptor allowance: %v", err)
} }
limit, err := getFdLimit() limit, err := fdlimit.Current()
if err != nil { if err != nil {
Fatalf("Failed to retrieve file descriptor allowance: %v", err) Fatalf("Failed to retrieve file descriptor allowance: %v", err)
} }

14
cmd/utils/fdlimit_freebsd.go → common/fdlimit/fdlimit_freebsd.go
Unescape View File

@ -16,7 +16,7 @@
// +build freebsd // +build freebsd
package utils package fdlimit
import "syscall" import "syscall"
@ -24,9 +24,9 @@ import "syscall"
// but Rlimit fields have type int64 on FreeBSD so it needs // but Rlimit fields have type int64 on FreeBSD so it needs
// an extra conversion. // an extra conversion.
// raiseFdLimit tries to maximize the file descriptor allowance of this process // Raise tries to maximize the file descriptor allowance of this process
// to the maximum hard-limit allowed by the OS. // to the maximum hard-limit allowed by the OS.
func raiseFdLimit(max uint64) error { func Raise(max uint64) error {
// Get the current limit // Get the current limit
var limit syscall.Rlimit var limit syscall.Rlimit
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
@ -43,9 +43,9 @@ func raiseFdLimit(max uint64) error {
return nil return nil
} }
// getFdLimit retrieves the number of file descriptors allowed to be opened by this // Current retrieves the number of file descriptors allowed to be opened by this
// process. // process.
func getFdLimit() (int, error) { func Current() (int, error) {
var limit syscall.Rlimit var limit syscall.Rlimit
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
return 0, err return 0, err
@ -53,9 +53,9 @@ func getFdLimit() (int, error) {
return int(limit.Cur), nil return int(limit.Cur), nil
} }
// getFdMaxLimit retrieves the maximum number of file descriptors this process is // Maximum retrieves the maximum number of file descriptors this process is
// allowed to request for itself. // allowed to request for itself.
func getFdMaxLimit() (int, error) { func Maximum() (int, error) {
var limit syscall.Rlimit var limit syscall.Rlimit
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
return 0, err return 0, err

10
cmd/utils/fdlimit_test.go → common/fdlimit/fdlimit_test.go
Unescape View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>. // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
package utils package fdlimit
import ( import (
"fmt" "fmt"
@ -25,7 +25,7 @@ import (
// per this process can be retrieved. // per this process can be retrieved.
func TestFileDescriptorLimits(t *testing.T) { func TestFileDescriptorLimits(t *testing.T) {
target := 4096 target := 4096
hardlimit, err := getFdMaxLimit() hardlimit, err := Maximum()
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -33,13 +33,13 @@ func TestFileDescriptorLimits(t *testing.T) {
t.Skip(fmt.Sprintf("system limit is less than desired test target: %d < %d", hardlimit, target)) t.Skip(fmt.Sprintf("system limit is less than desired test target: %d < %d", hardlimit, target))
} }
if limit, err := getFdLimit(); err != nil || limit <= 0 { if limit, err := Current(); err != nil || limit <= 0 {
t.Fatalf("failed to retrieve file descriptor limit (%d): %v", limit, err) t.Fatalf("failed to retrieve file descriptor limit (%d): %v", limit, err)
} }
if err := raiseFdLimit(uint64(target)); err != nil { if err := Raise(uint64(target)); err != nil {
t.Fatalf("failed to raise file allowance") t.Fatalf("failed to raise file allowance")
} }
if limit, err := getFdLimit(); err != nil || limit < target { if limit, err := Current(); err != nil || limit < target {
t.Fatalf("failed to retrieve raised descriptor limit (have %v, want %v): %v", limit, target, err) t.Fatalf("failed to retrieve raised descriptor limit (have %v, want %v): %v", limit, target, err)
} }
} }

14
cmd/utils/fdlimit_unix.go → common/fdlimit/fdlimit_unix.go
Unescape View File

@ -16,13 +16,13 @@
// +build linux darwin netbsd openbsd solaris // +build linux darwin netbsd openbsd solaris
package utils package fdlimit
import "syscall" import "syscall"
// raiseFdLimit tries to maximize the file descriptor allowance of this process // Raise tries to maximize the file descriptor allowance of this process
// to the maximum hard-limit allowed by the OS. // to the maximum hard-limit allowed by the OS.
func raiseFdLimit(max uint64) error { func Raise(max uint64) error {
// Get the current limit // Get the current limit
var limit syscall.Rlimit var limit syscall.Rlimit
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
@ -39,9 +39,9 @@ func raiseFdLimit(max uint64) error {
return nil return nil
} }
// getFdLimit retrieves the number of file descriptors allowed to be opened by this // Current retrieves the number of file descriptors allowed to be opened by this
// process. // process.
func getFdLimit() (int, error) { func Current() (int, error) {
var limit syscall.Rlimit var limit syscall.Rlimit
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
return 0, err return 0, err
@ -49,9 +49,9 @@ func getFdLimit() (int, error) {
return int(limit.Cur), nil return int(limit.Cur), nil
} }
// getFdMaxLimit retrieves the maximum number of file descriptors this process is // Maximum retrieves the maximum number of file descriptors this process is
// allowed to request for itself. // allowed to request for itself.
func getFdMaxLimit() (int, error) { func Maximum() (int, error) {
var limit syscall.Rlimit var limit syscall.Rlimit
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
return 0, err return 0, err

18
cmd/utils/fdlimit_windows.go → common/fdlimit/fdlimit_windows.go
Unescape View File

@ -14,13 +14,13 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>. // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
package utils package fdlimit
import "errors" import "errors"
// raiseFdLimit tries to maximize the file descriptor allowance of this process // Raise tries to maximize the file descriptor allowance of this process
// to the maximum hard-limit allowed by the OS. // to the maximum hard-limit allowed by the OS.
func raiseFdLimit(max uint64) error { func Raise(max uint64) error {
// This method is NOP by design: // This method is NOP by design:
// * Linux/Darwin counterparts need to manually increase per process limits // * Linux/Darwin counterparts need to manually increase per process limits
// * On Windows Go uses the CreateFile API, which is limited to 16K files, non // * On Windows Go uses the CreateFile API, which is limited to 16K files, non
@ -33,15 +33,15 @@ func raiseFdLimit(max uint64) error {
return nil return nil
} }
// getFdLimit retrieves the number of file descriptors allowed to be opened by this // Current retrieves the number of file descriptors allowed to be opened by this
// process. // process.
func getFdLimit() (int, error) { func Current() (int, error) {
// Please see raiseFdLimit for the reason why we use hard coded 16K as the limit // Please see Raise for the reason why we use hard coded 16K as the limit
return 16384, nil return 16384, nil
} }
// getFdMaxLimit retrieves the maximum number of file descriptors this process is // Maximum retrieves the maximum number of file descriptors this process is
// allowed to request for itself. // allowed to request for itself.
func getFdMaxLimit() (int, error) { func Maximum() (int, error) {
return getFdLimit() return Current()
} }
Write Preview
Loading…
Cancel
Save