[ruby-core:53688] [ruby-trunk - Feature #8158][Open] lightweight structure for loaded features index

[ruby-core:53688] [ruby-trunk - Feature #8158][Open] lightweight structure for loaded features index

[funny_falcon (Yura Sokolov)]

Issue #8158 has been reported by funny_falcon (Yura Sokolov).

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158

Author: funny_falcon (Yura Sokolov)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: current: 2.1.0


Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264


-- 
http://bugs.ruby-lang.org/

[ruby-core:53691] [ruby-trunk - Feature #8158] lightweight structure for loaded features index

[funny_falcon (Yura Sokolov)]

Issue #8158 has been updated by funny_falcon (Yura Sokolov).


Same for ruby_2_0_0 branch

https://github.com/funny-falcon/ruby/compare/ruby_2_0_0...features_index/ruby_2_0_0.diff
https://github.com/funny-falcon/ruby/compare/ruby_2_0_0...features_index/ruby_2_0_0
----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-37877

Author: funny_falcon (Yura Sokolov)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: current: 2.1.0


Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264


-- 
http://bugs.ruby-lang.org/

[ruby-core:54010] [ruby-trunk - Feature #8158] lightweight structure for loaded features index

[zzak (Zachary Scott)]

Issue #8158 has been updated by zzak (Zachary Scott).

File 264.patch added
Category set to core


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-38247

Author: funny_falcon (Yura Sokolov)
Status: Open
Priority: Normal
Assignee: 
Category: core
Target version: current: 2.1.0


Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264


-- 
http://bugs.ruby-lang.org/

[ruby-core:57523] [ruby-trunk - Feature #8158][Assigned] lightweight structure for loaded features index

[nobu (Nobuyoshi Nakada)]

Issue #8158 has been updated by nobu (Nobuyoshi Nakada).

Status changed from Open to Assigned
Assignee set to nobu (Nobuyoshi Nakada)


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-42137

Author: funny_falcon (Yura Sokolov)
Status: Assigned
Priority: Normal
Assignee: nobu (Nobuyoshi Nakada)
Category: core
Target version: current: 2.1.0


Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264


-- 
http://bugs.ruby-lang.org/

[ruby-core:60285] [ruby-trunk - Feature #8158] lightweight structure for loaded features index

[shibata.hiroshi]

Issue #8158 has been updated by Hiroshi SHIBATA.

Target version changed from 2.1.0 to current: 2.2.0

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-44768

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
* Category: core
* Target version: current: 2.2.0
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
264.patch (14.9 KB)


-- 
http://bugs.ruby-lang.org/

[ruby-core:77515] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.

File 0001-load.c-reduce-memory-usage-of-loaded_features_index.patch added

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-60778

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
264.patch (14.9 KB)
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.87 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:77516] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.


I've changed implementation a bit:
Because https://bugs.ruby-lang.org/issues/12142 likely to be accepted,
I've used st_table with numtable instead of separate datastructure.

So patch now is shorter.
https://bugs.ruby-lang.org/attachments/download/6182/0001-load.c-reduce-memory-usage-of-loaded_features_index.patch

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-60779

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
264.patch (14.9 KB)
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.87 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78595] Re: [Ruby trunk Feature#8158] lightweight structure for loaded features index

[Eric Wong]

funny.falcon@gmail.com wrote:
> So patch now is shorter.
> https://bugs.ruby-lang.org/attachments/download/6182/0001-load.c-reduce-memory-usage-of-loaded_features_index.patch

Thanks; this got broken by trivial whitespace change in r57032

I'm not sure about the portability of initializing structs
with non-const values for some compilers.  Maybe usa or
somebody with more portability experience can comment.

Also, in C Ruby; initial indent is 4 spaces, second indent is
hard tab.  Not my rule and I hate it; but not much we can do...

[ruby-core:78596] Re: [Ruby trunk Feature#8158] lightweight structure for loaded features index

[U.NAKAMURA]

Hi,

In message "[ruby-core:78595] Re: [Ruby trunk Feature#8158] lightweight structure for loaded features index"
  on Mon, 12 Dec 2016 06:06:13 +0000, normalperson@yhbt.net wrote:
> I'm not sure about the portability of initializing structs
> with non-const values for some compilers.  Maybe usa or
> somebody with more portability experience can comment.

It's OK, at least for VC++.


Regards,
-- 
U.Nakamaura <usa@garbagecollect.jp>

[ruby-core:78598] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[nobu]

Issue #8158 has been updated by Nobuyoshi Nakada.


Usaku NAKAMURA wrote:
>  In message "[ruby-core:78595] Re: [Ruby trunk Feature#8158] lightweight structure for loaded features index"
>  on Mon, 12 Dec 2016 06:06:13 +0000, normalperson@yhbt.net wrote:
>  > I'm not sure about the portability of initializing structs
>  > with non-const values for some compilers.  Maybe usa or
>  > somebody with more portability experience can comment.
>  
>  It's OK, at least for VC++.

Other compilers fail, IIRC, Solaris, AIX, HP-UX, or something.

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61982

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
264.patch (14.9 KB)
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.87 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78599] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.


I'll fix patch today.

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61983

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
264.patch (14.9 KB)
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.87 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78600] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.

File 0001-load.c-reduce-memory-usage-of-loaded_features_index.patch added

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61986

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78601] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.


I've uploaded fixed patch:
https://bugs.ruby-lang.org/attachments/download/6293/0001-load.c-reduce-memory-usage-of-loaded_features_index.patch

Github branch and diff:
https://github.com/funny-falcon/ruby/tree/loaded_features_strings
https://github.com/ruby/ruby/compare/trunk...funny-falcon:loaded_features_strings.patch

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61987

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78604] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.

File load.c-loaded_features_numindex.patch added

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61989

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78605] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.

File load.c-loaded_features_numindex.patch added

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61991

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78606] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.


I've tried to simplify patch: remove `struct feature_str` and use just pointer with len.

https://bugs.ruby-lang.org/attachments/download/6295/load.c-loaded_features_numindex.patch

https://github.com/ruby/ruby/compare/trunk...funny-falcon:loaded_features_index.patch
https://github.com/funny-falcon/ruby/tree/loaded_features_index


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-61992

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:78780] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[shyouhei]

Issue #8158 has been updated by Shyouhei Urabe.


We looked at this issue at today's developer meeting and had positive opinions.  Maybe introduced in 2.5.

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-62182

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:79133] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[matz]

Issue #8158 has been updated by Yukihiro Matsumoto.


The patch seems OK now. @funny_falcon do you want to check in by yourself?

Matz.

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-62547

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:79164] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by Yura Sokolov.


Matz,

I don't know English enough to clearly understand your suggestion.

Is it suggestion of commit rights?
If it is, it will be a great honor for me.
But I'm not even-tempered person, and I fear I will put a mess into repository if I will have commit rights.

If your suggestion means some-thing else, then may you formulate it in some other words so I can understand?

With regards,
Yura.


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-62582

* Author: Yura Sokolov
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85530] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[sam.saffron]

Issue #8158 has been updated by sam.saffron (Sam Saffron).


Hi Yura, 

I think the commit rights here reduce the amount of work for the rest of the Ruby team. 

This change is approved and reviewed, so you can commit it directly once you have the rights, no need to make other people do the committing. 

Very keen to have this change included in Ruby. 

Sam 

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70318

* Author: funny_falcon (Yura Sokolov)
* Status: Assigned
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85543] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by funny_falcon (Yura Sokolov).


Year after I think I am more stable person, so I'm going to accept commit rights with gratitude, honor and great responsibility.

But until I passed procedure, I'd be thankful if @tenderlovemaking will commit this one.

With regards,
Yura.

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70337

* Author: funny_falcon (Yura Sokolov)
* Status: Assigned
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85554] [Ruby trunk Feature#8158][Closed] lightweight structure for loaded features index

[tenderlove]

Issue #8158 has been updated by tenderlovemaking (Aaron Patterson).

Status changed from Assigned to Closed

Committed in r62404.  Thanks Yura!!

----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70347

* Author: funny_falcon (Yura Sokolov)
* Status: Closed
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85588] Re: [Ruby trunk Feature#8158] lightweight structure for loaded features index

[Eric Wong]

> https://bugs.ruby-lang.org/issues/8158

I am curious, what is the significance of the 0xfea7009e
initializer passed to st_hash?

Would it be appropriate to use for the `st_hash' call in
hash.c::hash_i as well?

Thanks.

[ruby-core:85673] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[matz]

Issue #8158 has been updated by matz (Yukihiro Matsumoto).


@funny_falcon? Will you be a committer?

Matz.


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70465

* Author: funny_falcon (Yura Sokolov)
* Status: Closed
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85690] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by funny_falcon (Yura Sokolov).


@matz , yes I will.
Excuse me for the delay. I'll try to proceed with steps from CommitterHowto this week.

With regards,
Yura.


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70494

* Author: funny_falcon (Yura Sokolov)
* Status: Closed
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85691] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[funny.falcon]

Issue #8158 has been updated by funny_falcon (Yura Sokolov).


normalperson (Eric Wong) wrote:

> > https://bugs.ruby-lang.org/issues/8158
>  
>  I am curious, what is the significance of the 0xfea7009e
>  initializer passed to st_hash?

0xfea7009e - is a "feature" hex-spelled :-) Nothing special.
It could be ommitted, given features are strings without zero bytes.
I put it here just for fun.

>  Would it be appropriate to use for the `st_hash' call in
>  hash.c::hash_i as well?

I believe, there's no real needs.

>  Thanks.

With regards,
Yura.


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70495

* Author: funny_falcon (Yura Sokolov)
* Status: Closed
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/

[ruby-core:85774] [Ruby trunk Feature#8158] lightweight structure for loaded features index

[hsbt]

Issue #8158 has been updated by hsbt (Hiroshi SHIBATA).


Hi all.

I did create an account of funny_falcon on svn.ruby-lang.org.


----------------------------------------
Feature #8158: lightweight structure for loaded features index
https://bugs.ruby-lang.org/issues/8158#change-70621

* Author: funny_falcon (Yura Sokolov)
* Status: Closed
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
----------------------------------------
Use lightweight structure for loaded_features index:

- use hand made simple hash structure, which uses only one memory chunk,
- do not store feature name string, only hash of it, since loaded_feature_path
  will recheck feature name on hash collision
- use single linked lists instead of arrays for storing features indices.
- store this lists inside one array, using array's indices as a reference.

While startup speedup improvement is relatively small compared current implementation,
this one does not need any Ruby Objects at all, so that there is no presure on GC.

https://github.com/ruby/ruby/pull/264.patch
https://github.com/ruby/ruby/pull/264.diff
https://github.com/ruby/ruby/pull/264

---Files--------------------------------
0001-load.c-reduce-memory-usage-of-loaded_features_index.patch (5.99 KB)
load.c-loaded_features_numindex.patch (4.99 KB)


-- 
https://bugs.ruby-lang.org/