self->hash API: inline, not indirect calls #21
Comments
rurban
added a commit
that referenced
this issue
Mar 28, 2021
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Mar 28, 2021
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Apr 4, 2021
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Apr 24, 2021
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Oct 13, 2021
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Apr 12, 2023
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Jul 17, 2023
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Feb 16, 2024
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Feb 16, 2024
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Feb 20, 2024
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Feb 21, 2024
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
rurban
added a commit
that referenced
this issue
Feb 21, 2024
use static methods, prefixed by the type T. This enables inlining the hot hashtable parts, and disallows corrupting the table with changed hash or equal methods. They really need to be declared and defined statically, just as with C++, where we need to declare it for the template. Fixes GH #21
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
mandate
T_hashto be defined, resp.TK_hash, beforehand. Don't call it indirectly.There's no need to dynamically change it, it needs to be compile-time.
Similarily for the same for the equal and compare funcs.
No need from them to be stored in the container. Inline them.
hash is esp. performance sensitive, but also security. just NULL it to create a DDOS.
The text was updated successfully, but these errors were encountered: