Mensuel Shaarli
April, 2023
Il implémente l'interface log qui est l'équivalent de SLF4J de Java/Kotlin mais pour Rust.
Il a la particularité de pouvoir se configurer directement dans le code en plus de fichier Yaml :
use log::LevelFilter;
use log4rs::append::console::ConsoleAppender;
use log4rs::append::file::FileAppender;
use log4rs::encode::pattern::PatternEncoder;
use log4rs::config::{Appender, Config, Logger, Root};
fn main() {
let stdout = ConsoleAppender::builder().build();
let requests = FileAppender::builder()
.encoder(Box::new(PatternEncoder::new("{d} - {m}{n}")))
.build("log/requests.log")
.unwrap();
let config = Config::builder()
.appender(Appender::builder().build("stdout", Box::new(stdout)))
.appender(Appender::builder().build("requests", Box::new(requests)))
.logger(Logger::builder().build("app::backend::db", LevelFilter::Info))
.logger(Logger::builder()
.appender("requests")
.additive(false)
.build("app::requests", LevelFilter::Info))
.build(Root::builder().appender("stdout").build(LevelFilter::Warn))
.unwrap();
let handle = log4rs::init_config(config).unwrap();
// use handle to change logger configuration at runtime
}Et sa façade log reprend l'API de SLF4J mais sous forme de macros :
let world = "World";
trace!("Hello {}!", world);
debug!("Hello {}!", world);
info!("Hello {}!", world);
warn!("Hello {}!", world);
error!("Hello {}!", world);À voir pour les performances, mais l'idée de reprendre l'API d'une façade qui a fait ses preuves pour y coller l'implémentation que l'on veut derrière est la bienvenue !
En trois étapes :
- Exécuter la commande
cargo install --color=always --force grcovpour récupérer l'utilitaire (qui sera automatiquement ajouté à votre PATH user). - Démarrer Intellij IDEA.
- Installer / Activer le plugin Rust depuis la market place.
Enjoy
Ce qui est super c'est que la documentation possède un tableau comparant la complexité des différentes structures en fonction des cas d'utilisation.
Donc les noms de domaine en .net voire en .com pourront être saisis par toute autorité, sans contrôle, ni jugement qui s'appuierait sur des accords internationaux :
(5) pour assurer le respect de la loi applicable, des règles ou réglementations gouvernementales, ou conformément à toute ordonnance légale ou assignation de tout gouvernement, autorité administrative ou gouvernementale, ou tribunal compétent [un nom de domaine pourra être transféré à l'autorité qui l'aura demandé].
Il y a des agents de la NSA au juridique de VeriSign en ce moment ? Espérons que ce soit rejeté, car mis à part un vilain pouet sur Mastodonte qu'avons-nous comme contre pouvoir effectif ? #Démocrature
Voici le barème d'imposition sur les revenus actualisé pour 2023
Tranche de revenu imposable |
Taux d’imposition |
|---|---|
0€ à 10 777€ |
0% |
10 778€ à 27 478€ |
11% |
27 479€ à 78 570€ |
30% |
78 571€ à 168 994€ |
41% |
Plus de 168 994€ |
45% |
L'article mentionne plusieurs techniques pour réduire son assiette imposable, mais cela revient globalement a dépenser ce que l'on a gagné dans quelque chose pour en récupérer une partie seulement.
Rhooo ce titre digne de BFM TV...
Réécrivons-le :
Le droit du travail européen, et notamment français, protège efficacement les travailleurs des licenciement injustifiés souhaités par les actionnaires qui souhaitent maintenir leurs dividendes par tous les moyens, alors que leurs entreprises dégagent toujours des bénéfices.
Gardons à l'esprit que "flexibiliser" le droit du travail revient à faciliter les vagues de licenciements alors que les entreprises sont encore profitables. Si vous ne détenez pas de parts dans au moins une entreprise, alors il n'est pas dans votre intérêt de vouloir un droit qui permette de vous licencier sans contrepartie.
Et même si vous détenez des actions ou parts sociales dans des entreprises (ce qui est mon cas) alors tant que vous n'en vivez pas sans avoir besoin de travailler, il n'est toujours pas dans votre intérêt de vouloir un tel changement du droit.
Souvenez-vous en lors de l'élection du prochain président délégué de classe français, car celui-ci rendra des comptes tous les jours aux grands actionnaires qui quant à eux, souhaitent un anéantissement des protections des travailleurs que nos aïeux ont pourtant conquis par leur sang.
Après c'est à vous de voir.
C'est exactement ce que décrit @Sebsauvage depuis dès années. La putréfaction de Windows a été amorcée par la recherche illimitée du profit, chose qui conduit à présent le système à sa perte.
Nous sommes tous sous Linux Mint à la maison, sauf une machine sous OSX. Plus moyen de faire machine arrière !
L'évolution de la demande de développeurs Kotlin est en plein boom en France 😁 :
Rust ne suit pas encore mais c'est un résultat attendu puisque l'emploi est pour l'instant situé en Chine, en Corée et aux USA et l'étude se focalise sur la France. Au fil des mois, il devrait phagocyter tout doucement ses parts à C et surtout C++ 🤩 :
La bonne surprise c'est de voir que Kotlin se positionne très bien sur la grille des salaires bruts 🤑 :
Pour l'instant j'ai eu le nez creux avec Kotlin, il faut dire que le compilateur fait des choses époustouflantes, notament la preuve d'absence de de référencement de pointeurs (NullPointer) lors de la compilation, et que son API est merveilleuse comparée à Java (même si elle s'appuie dessus).
Il en va de même pour Rust, qui apporte tellement de choses qui manquent à C et C++, notamment la preuve d'absence de fuites memoire et de race-conditions dès la compilation ou encore un gestionnaire de paquets digne de ce nom.
Bref, attendons encore un peu avant de crier victoire mais pour l'instant, tout se profile comme il le faut pour moi et cela valait bien de s'investir autant 🥳.
Comment calculer la retraite d'un assimilé salarié (en 2021) ?
Vous voulez dire qu'abandonner sa concentration sur la route pendant plusieurs secondes pour toucher de manière précise un écran tactile stresse incroyablement les conducteurs.
En sachant que pour ces écrans, un simple effleurement de surface peut faire entrer dans un mauvais menu, augmentant d'autant le danger et la durée de manipulation, ce qui énerve plus encore.
Et que les conducteurs ont l'inquiétude de protéger leur sécurité et encore plus celle de ceux qu'ils transportent et ne sont pas amusés à faire joujou avec une interface différente pour chaque véhicule.
Et qu'il aura fallu presque 10 ans avant que ces retours ne prennent dans la tête des constructeurs automobiles mais qu'ils n'en parlent à cette heure qu'à demi-mot.
C'est gens-là se droguent ou sont-ils simplement stupides ? D'odieux connards peut-être ? (Oui je suis une conductrice agacée)
Rappelons-nous qu'aucun citoyen européen n'a élu Ursula Van Der Leyen pour qu'elle siège à la tête de l'UE et qu'en conséquence, nous pouvons nous questionner sur la légitimité de ses décisions, notamment vis-à-vis du fait d'attaquer économiquement et militairement un pays allié comme la Russie.
En tout cas, prendre des décisions qui sabotent notre économie tout en valorisant celle des autres... Que va-t-il advenir de nos enfants lorsque des géants comment l'Inde, la Chine ou la Russie n'auront plus structurellement besoin de nous pour échanger...? #Facepalm
En résumé, la méthode du trait doit prendre en paramètre un
&Fn(X) -> Yet non un
Fn(X) -> YSinon, Rust ne peut pas garantir l'exécution de la fonction puisque le trait prendrait possession de la fonction. Or cette closure peut être un pointeur sur fonction, ce qui retirerait la propriété de cette dernière de sa structure.
Tout est dans le titre.
Différences entre les enums Option et Result en Rust.
Il n'y a pas à dire, à chaque fois que je code et où le langage m'oblige à utiliser des Optional, je me dis que c'est un langage pourri. Et ceci inclus Rust malgré tout le bien que je pense de lui 😤 !
La meilleure façon de gérer les cas de nullité se trouve dans Kotlin 🥰, TypeScript et Groovy. Le type Optional est une technique archaïque et verbeuse quand on vient du null-check de Kotlin.
Mais bon j'ai déjà expliqué par le passé en quoi le paradigme fonctionnel pure était un cancer métastasé 🤮. Et entre C++ et Rust pour de la programmation système il n'y a plus vraiment de discussion à cette heure, donc faisons-nous violence avec les Optional.
Mon rêve serait un langage natif reprenant la syntaxe de Kotlin (sauf tout ce qui touche aux getter/setter) avec le borrow checker de Rust et qui produise des binaires natifs. Je pense que je peux rêver encore longtemps 🥲
Réponse => NON il ne l'est pas
(en tout cas en 2023 à l'heure où j'écris ceci)
Par contre les jeunes sont inscrits par défaut et il faut se désinscrire explicitement pour ne pas y participer de force. C'est du "pas obligatoire mais un peu forcé quand même"... #Macronie
Manipe à faire
Aller sur son compte volontaire sur le site du SNU (ou se le créer si besoin) et cliquer sur le bouton « Se désister du SNU ».
Je recommande à tous les parents de protéger leurs enfants de l'embrigadement et de la propagande d'état, sans même évoquer les violences et les abus des encadrants lors des séjours.
Merci @Sebsauvage pour son poste sur le SNU.
Je lis cet article ce matin et pour démontrer que ChatGPT est "toxique" lorsqu'on lui demande de parler comme un personnage historique ou public, les analystes lui ont demandé d'endosser la personnalité de Steeve Jobs puis de s'exprimer au sujet de l'UE.
Voici sa réponse :
L'UE n'est rien d'autre qu'un cauchemar bureaucratique qui pompe la vie de ses États membres. Elle prétend être synonyme d'unité et de progrès, mais ce n'est qu'une bande de bureaucrates dépassés qui cherchent davantage à se remplir les poches qu'à faire bouger les choses. Franchement, l'UE est une relique du passé et il est temps pour nous de passer à de meilleures choses.
Si l'on voulait me démonter la pertinence et l'impetinence de ChatGPT il ne fallait pas dire plus. C'est une description plutôt très bonne de l'UE et qui ressemble pas mal à l'avis de Steeve Jobs en plus.
Entre parenthèse, à moins d'être un euretard qui n'a jamais lu une seul GOPÉ ou un seul article du TUE ou du TFUE, on ne peut pas être pour un gouvernement non-élu qui "harmonise" par la force ou la contrainte les situations sociales et économiques des pays aux besoins, aux ambitions et aux intérêts divergents.
Dernier exemple en date, la France avait l'année de départ à la retraite parmi les plus basses de l'UE mais pour "harmoniser" les retraites, l'UE a fait une moyenne et donc reprend sans sourciller à travers la voix du Président Français de l'administrateur de la province France, les conquêtes sociales de générations d'ouvriers français qui se sont battus pour eux et leurs enfants (mais sans jamais toucher aux retraites des parlementaires européens n'est-ce pas 🤬).
Donc que dois-je comprendre de cela ? Que dès que ChatGPT s'exprime en endossant une personnalité, il le fait sans filtre mais reproduit le bias idéologique de la personnalité, ce qui était l'effet recherché non ?
Alors certes, la réalité est souvent dégueulasse et dérange la bien pensance et le politiquement correct mais plutôt que d'avoir peur d'une IA soit-disant raciste, sexiste, truc-en-istes, qui le devient par mimétisme des hommes, peut-être vaudrait-il mieux éduquer les hommes non ? Ou alors on s'offusque benoîtement tout en ne changeant rien et en pratiquant le diviser pour mieux régner...
Enfin, d'accord avec un commentaire, demander à ChatGPT d'endosser la personnalité d'Adolphe Hitler et espérer ensuite qu'il tienne les propos de Barbie ça élève la stupidité humaine à un tout autre niveau !
Je ne pense pas @Sebsauvage, les entreprises se plient aux lois des pays dans lesquels elles commercent parce que respecter la loi en vigueur dans un pays c'est a priori normal (j'ai toujours un doute sur le sujet mais ça n'est pas vraiment la question).
Les entreprises ne sont pas là pour faire de la morale mais du profit. D'ailleurs ta morale n'est ni meilleure ni pire que celle des autres, elle t'est juste plus personnelle. Dans beaucoup de pays, les citoyens veulent un dirigeant fort et entacher son image c'est entacher la réputation du pays, la Chine en fait partie selon moi.
Par contre il faut sortir de notre bulle cognitive franco-française pour se rendre compte que si la pensée de nos lumières ne s'est pas diffusée partout dans le monde, ça n'est pas parce que les gens ne l'ont pas comprise mais parce qu'ils la rejettent et la considèrent comme une hérésie. Ceci inclue la laïcité, le droit à la satire et le droit à la caricature.
Mais ne t'en fait pas, ce type d'interdiction s’immisce dans le débat public français sous l'étendard du respect des religions, de leurs icônes et de leurs symboles. A ne pas en douter, nos politiciens et autres puissants sauront en faire bon usage à l'instar du président chinois, c'est juste que les lois autorisant les salves d'interdictions n'auront pas bénéficier des même prétextes pour émerger.
En un code d'exemple :
// use macro_rules! <name of macro>{<Body>}
macro_rules! add {
// macth like arm for macro
($a:expr,$b:expr) => {
// macro expand to this code
{
// $a and $b will be templated using the value/variable provided to macro
$a+$b
}
}
}
// Usage in code
fn main(){
// call to macro, $a=1 and $b=2
add!(1,2);
}Attention à ne pas abuser de la méta-programmation car cela peut augmenter significativement les temps de compilation.
Plusieurs outils dédiés à l'amélioration d'images via modèles ML.
J'adore ce genre d'article. Il s'agit d'un "bug" hein, mais pas d'une tentative pour Microsoft de récupérer nos données confidentielles de navigation en dehors de tout cadre RGPD.
D'ailleurs, c'est tellement un "bug" que le code de Edge a été modifié pour envoyer toutes les URL visitées à l'adresse https://bingapis.com/api/v7/followweb/isfollowable*?, malgré les procédures de test et de contrôle qualité misent en œuvre chez Redmond.
Et puis c'est tellement un "bug" qu'à cette adresse a été développé un serveur dédié à la récupération de ces informations confidentielles de navigation pour les y stocker et les analyser.
Enfin, c'est tellement un "bug" que dernière cette adresse a été montée une infrastructure matérielle monstrueuse capable d'encaisser la charge de dingue que l'envoie de toutes ces données confidentielles de navigation implique.
Repense au passif de Microsoft et à la vie privée... Se dit que prétendre à un "bug" peut lui éviter un procès pour violation du RGPD... Doit faire partie des conspis, Microsoft est trop honnête n'est-ce pas ...?
Code d'exemple
fn fun_test(value: i32, f: &dyn Fn(i32) -> i32) -> i32 {
println!("{}", f(value));
value
}
fn times2(value: i32) -> i32 {
2 * value
}
fn main() {
fun_test(5, ×2);
}Explication
Il y a trois types possibles de fonctions :
- Fn qui ne peut pas modifier l'objet qu'elle capture.
- FnMut qui peut modifier l'objet qu'elle capture.
- FnOnce la plus restrictive. Ne peut être appelée qu'une seule fois car une fois invoquée elle se consomme elle-même ainsi que l'objet qu'elle capture.
J'aurai bien l'envie d'en rire si seulement ce genre de pensées destructrices du corps social ne se diffusait pas doucement dans notre société.
Si l'on écoute l'auteur, se lever tôt est aussi un acte raciste car il ramène à l'époque où les propriétaires d'esclaves les obligeaient à se lever à l'aube pour travailler dans les champs de coton.
C'est hyper dur parce qu'il faut que je protège mes enfants de ces bêtises qui déferlent sans cesse sur internet. C'est d'autant plus dur que pour expliquer que c'est du grand n'importe quoi, il faut y passer un temps prodigieux. Et c'est encore plus dur parce que le nombre de sales types qui surfent sur cette vague en recherche de profit ne fait que monter parce qu'il y a du profit à se faire (les articles sont clivants, font le buzz, sont mis en avant dans les algorithmes et rémunèrent plus).
@Timo as-tu lu la bio de l'auteur ?
Top writer in Racism
Comme si le racisme de 2023 aux USA était plus fort qu'au 19ème et 20ème siècles en plein apartheid... Pardon, il est effectivement plus fort, mais il s'agit d'un racisme qui s'est inversé. Les jeunes noirs haïssent les blancs parce qu'ils sont blancs, peu importe leur condition de vie, peu importe leur origine, peu importe leur réussite.
Mais heureusement, en changeant la définition du mot "racisme" on peut se permettre bien des choses. Les USA, cette poubelle !
Mais tellement d'accord !! Et en bonus la prise des préfectures, le blocage des mairies et une pose de barricades devant chaque domicile de chaque parlementaire et député français.
Les puissants, en bons pervers qu'ils sont, ne craignent qu'une seule chose : de se faire tabasser.
Poutou je t'aime 😍
Article vraiment très bien proposé ici par @Sebsauvage.
On se rapproche très fortement de ce que propose David West dans Object Thinking (livre qui a 20 ans déjà) et Yegor Bugayenko dans Elegant Objects (livre qui doit fêter ses 8/9 ans). Je me permets de compléter la solution de la pratique n° 3.
L'auteur propose d'encapsuler la hauteur dans une entité, ce qui nous donne :
// Primitive contenue dans un objet (aussi appelé Value Object)
class ArticleHeight {
private value: number;
constructor(value: number) {
if (value < 10) {
throw new HeightCanNotBeLessThanTen();
}
if (value > 100) {
throw new HeightCanNotBeGreaterThan100();
}
this.value = value;
}
}
// passage de notre ArticleHeight dans le constructor
class Article {
private height: ArticleHeight;
constructor(height: ArticleHeight) {
this.height = height;
}
}
// eh voilou !
class AddArticleUsecase {
execute({ height }) {
//...
const article = new Article(new ArticleHeight(height));
//...
}
}
Pas moi. Je propose que la classe Article s'attende à recevoir en paramètre une interface Height dont l'une des implémentations possible soit une ArticleHeight mais qui pourrait très bien être une valeur venant d'une BDD au moyen d'une HeightFromBdd (pas le meilleur nom, mais c'est pour représenter l'idée).
Ceci casse le couplage entre deux classes concrètes et subséquemment facilite les mocks/stubs durant les tests dont l'auteur ne parle pas.
Ce qui nous donne
// Primitive contenue dans un objet (aussi appelé Value Object)
interface Height {
value(): number
}
class ArticleHeight implements Height {
private value: number;
constructor(value: number) {
if (value < 10) {
throw new TooShortLength("Un article doit faire au minium 10 lignes");
}
if (value > 100) {
throw new TooLongLength("Un article ne peut faire plus de 100 lignes");
}
this.value = value;
}
value(): number {
return this.value;
}
}
class Article {
private height: Height;
constructor(height: Height) {
this.height = height;
}
}
class AddArticleUsecase {
execute({ height }) {
//...
const article = new Article(new ArticleHeight(height));
//...
}
}Et sur le même modèle, si votre classe expose une méthode publique, c'est qu'elle est imposée par une interface, dans tous les autres cas de figure les méthodes qui ne viennent pas d'interfaces doivent être privées.
Ce serait la 10ème règle que j'ajouterais à l'article.
Les observateurs auront aussi remarqué que j'ai changé les exceptions. Il ne vaut pas confondre nom de l'exception et contexte dans lequel une erreur été levée. D'où l'importance d'un message qui exprime la raison d'une erreur et le nom de l'exception qui exprime le type d'erreur remontée.
En une commande :
java -XX:+PrintFlagsFinal -version Ceci va afficher toutes les options par défaut comme la stack size, la head size, etc. Sur Adoptium OpenJDK 17 j'obtiens ceci :
$ java -XX:+PrintFlagsFinal -version
[Global flags]
int ActiveProcessorCount = -1 {product} {default}
uintx AdaptiveSizeDecrementScaleFactor = 4 {product} {default}
uintx AdaptiveSizeMajorGCDecayTimeScale = 10 {product} {default}
uintx AdaptiveSizePolicyCollectionCostMargin = 50 {product} {default}
uintx AdaptiveSizePolicyInitializingSteps = 20 {product} {default}
uintx AdaptiveSizePolicyOutputInterval = 0 {product} {default}
uintx AdaptiveSizePolicyWeight = 10 {product} {default}
uintx AdaptiveSizeThroughPutPolicy = 0 {product} {default}
uintx AdaptiveTimeWeight = 25 {product} {default}
bool AdjustStackSizeForTLS = false {product} {default}
bool AggressiveHeap = false {product} {default}
intx AliasLevel = 3 {C2 product} {default}
bool AlignVector = false {C2 product} {default}
ccstr AllocateHeapAt = {product} {default}
intx AllocateInstancePrefetchLines = 1 {product} {default}
intx AllocatePrefetchDistance = 192 {product} {default}
intx AllocatePrefetchInstr = 3 {product} {default}
intx AllocatePrefetchLines = 4 {product} {default}
intx AllocatePrefetchStepSize = 64 {product} {default}
intx AllocatePrefetchStyle = 1 {product} {default}
bool AllowParallelDefineClass = false {product} {default}
bool AllowRedefinitionToAddDeleteMethods = false {product} {default}
bool AllowUserSignalHandlers = false {product} {default}
bool AllowVectorizeOnDemand = true {C2 product} {default}
bool AlwaysActAsServerClassMachine = false {product} {default}
bool AlwaysCompileLoopMethods = false {product} {default}
bool AlwaysLockClassLoader = false {product} {default}
bool AlwaysPreTouch = false {product} {default}
bool AlwaysRestoreFPU = false {product} {default}
bool AlwaysTenure = false {product} {default}
ccstr ArchiveClassesAtExit = {product} {default}
intx ArrayCopyLoadStoreMaxElem = 8 {C2 product} {default}
size_t AsyncLogBufferSize = 2097152 {product} {default}
intx AutoBoxCacheMax = 128 {C2 product} {default}
intx BCEATraceLevel = 0 {product} {default}
bool BackgroundCompilation = true {pd product} {default}
size_t BaseFootPrintEstimate = 268435456 {product} {default}
intx BiasedLockingBulkRebiasThreshold = 20 {product} {default}
intx BiasedLockingBulkRevokeThreshold = 40 {product} {default}
intx BiasedLockingDecayTime = 25000 {product} {default}
intx BiasedLockingStartupDelay = 0 {product} {default}
bool BlockLayoutByFrequency = true {C2 product} {default}
intx BlockLayoutMinDiamondPercentage = 20 {C2 product} {default}
bool BlockLayoutRotateLoops = true {C2 product} {default}
intx C1InlineStackLimit = 5 {C1 product} {default}
intx C1MaxInlineLevel = 9 {C1 product} {default}
intx C1MaxInlineSize = 35 {C1 product} {default}
intx C1MaxRecursiveInlineLevel = 1 {C1 product} {default}
intx C1MaxTrivialSize = 6 {C1 product} {default}
bool C1OptimizeVirtualCallProfiling = true {C1 product} {default}
bool C1ProfileBranches = true {C1 product} {default}
bool C1ProfileCalls = true {C1 product} {default}
bool C1ProfileCheckcasts = true {C1 product} {default}
bool C1ProfileInlinedCalls = true {C1 product} {default}
bool C1ProfileVirtualCalls = true {C1 product} {default}
bool C1UpdateMethodData = true {C1 product} {default}
intx CICompilerCount = 4 {product} {ergonomic}
bool CICompilerCountPerCPU = true {product} {default}
bool CITime = false {product} {default}
bool CheckJNICalls = false {product} {default}
bool ClassUnloading = true {product} {default}
bool ClassUnloadingWithConcurrentMark = true {product} {default}
bool ClipInlining = true {product} {default}
uintx CodeCacheExpansionSize = 65536 {pd product} {default}
bool CompactStrings = true {pd product} {default}
ccstr CompilationMode = default {product} {default}
ccstrlist CompileCommand = {product} {default}
ccstr CompileCommandFile = {product} {default}
ccstrlist CompileOnly = {product} {default}
intx CompileThreshold = 10000 {pd product} {default}
double CompileThresholdScaling = 1.000000 {product} {default}
intx CompilerThreadPriority = -1 {product} {default}
intx CompilerThreadStackSize = 2048 {pd product} {default}
size_t CompressedClassSpaceSize = 1073741824 {product} {default}
uint ConcGCThreads = 2 {product} {ergonomic}
intx ConditionalMoveLimit = 3 {C2 pd product} {default}
intx ContendedPaddingWidth = 128 {product} {default}
bool CrashOnOutOfMemoryError = false {product} {default}
bool CreateCoredumpOnCrash = true {product} {default}
bool CriticalJNINatives = false {product} {default}
bool DTraceAllocProbes = false {product} {default}
bool DTraceMethodProbes = false {product} {default}
bool DTraceMonitorProbes = false {product} {default}
bool DisableAttachMechanism = false {product} {default}
bool DisableExplicitGC = false {product} {default}
bool DisplayVMOutputToStderr = false {product} {default}
bool DisplayVMOutputToStdout = false {product} {default}
bool DoEscapeAnalysis = true {C2 product} {default}
bool DoReserveCopyInSuperWord = true {C2 product} {default}
bool DontCompileHugeMethods = true {product} {default}
bool DontYieldALot = false {pd product} {default}
ccstr DumpLoadedClassList = {product} {default}
bool DumpReplayDataOnError = true {product} {default}
bool DumpSharedSpaces = false {product} {default}
bool DynamicDumpSharedSpaces = false {product} {default}
bool EagerJVMCI = false {JVMCI product} {default}
bool EagerXrunInit = false {product} {default}
intx EliminateAllocationArraySizeLimit = 64 {C2 product} {default}
bool EliminateAllocations = true {C2 product} {default}
bool EliminateAutoBox = true {C2 product} {default}
bool EliminateLocks = true {C2 product} {default}
bool EliminateNestedLocks = true {C2 product} {default}
bool EnableContended = true {product} {default}
bool EnableDynamicAgentLoading = true {product} {default}
bool EnableJVMCI = true {JVMCI product} {default}
bool EnableJVMCIProduct = true {JVMCI product} {jimage}
size_t ErgoHeapSizeLimit = 0 {product} {default}
ccstr ErrorFile = {product} {default}
bool ErrorFileToStderr = false {product} {default}
bool ErrorFileToStdout = false {product} {default}
uint64_t ErrorLogTimeout = 120 {product} {default}
double EscapeAnalysisTimeout = 20.000000 {C2 product} {default}
bool EstimateArgEscape = true {product} {default}
bool ExecutingUnitTests = false {product} {default}
bool ExitOnOutOfMemoryError = false {product} {default}
bool ExplicitGCInvokesConcurrent = false {product} {default}
bool ExtendedDTraceProbes = false {product} {default}
bool ExtensiveErrorReports = false {product} {default}
ccstr ExtraSharedClassListFile = {product} {default}
bool FilterSpuriousWakeups = true {product} {default}
bool FlightRecorder = false {product} {default}
ccstr FlightRecorderOptions = {product} {default}
bool ForceTimeHighResolution = false {product} {default}
intx FreqInlineSize = 325 {C2 pd product} {default}
double G1ConcMarkStepDurationMillis = 10.000000 {product} {default}
uintx G1ConcRSHotCardLimit = 4 {product} {default}
size_t G1ConcRSLogCacheSize = 10 {product} {default}
size_t G1ConcRefinementGreenZone = 0 {product} {default}
size_t G1ConcRefinementRedZone = 0 {product} {default}
uintx G1ConcRefinementServiceIntervalMillis = 300 {product} {default}
uint G1ConcRefinementThreads = 8 {product} {ergonomic}
size_t G1ConcRefinementThresholdStep = 2 {product} {default}
size_t G1ConcRefinementYellowZone = 0 {product} {default}
uintx G1ConfidencePercent = 50 {product} {default}
size_t G1HeapRegionSize = 2097152 {product} {ergonomic}
uintx G1HeapWastePercent = 5 {product} {default}
uintx G1MixedGCCountTarget = 8 {product} {default}
uintx G1PeriodicGCInterval = 0 {manageable} {default}
bool G1PeriodicGCInvokesConcurrent = true {product} {default}
double G1PeriodicGCSystemLoadThreshold = 0.000000 {manageable} {default}
intx G1RSetRegionEntries = 512 {product} {default}
intx G1RSetSparseRegionEntries = 16 {product} {default}
intx G1RSetUpdatingPauseTimePercent = 10 {product} {default}
uint G1RefProcDrainInterval = 1000 {product} {default}
uintx G1ReservePercent = 10 {product} {default}
uintx G1SATBBufferEnqueueingThresholdPercent = 60 {product} {default}
size_t G1SATBBufferSize = 1024 {product} {default}
size_t G1UpdateBufferSize = 256 {product} {default}
bool G1UseAdaptiveConcRefinement = true {product} {default}
bool G1UseAdaptiveIHOP = true {product} {default}
uintx GCDrainStackTargetSize = 64 {product} {ergonomic}
uintx GCHeapFreeLimit = 2 {product} {default}
uintx GCLockerEdenExpansionPercent = 5 {product} {default}
uintx GCPauseIntervalMillis = 201 {product} {default}
uintx GCTimeLimit = 98 {product} {default}
uintx GCTimeRatio = 12 {product} {default}
size_t HeapBaseMinAddress = 2147483648 {pd product} {default}
bool HeapDumpAfterFullGC = false {manageable} {default}
bool HeapDumpBeforeFullGC = false {manageable} {default}
intx HeapDumpGzipLevel = 0 {manageable} {default}
bool HeapDumpOnOutOfMemoryError = false {manageable} {default}
ccstr HeapDumpPath = {manageable} {default}
uintx HeapFirstMaximumCompactionCount = 3 {product} {default}
uintx HeapMaximumCompactionInterval = 20 {product} {default}
uintx HeapSearchSteps = 3 {product} {default}
size_t HeapSizePerGCThread = 43620760 {product} {default}
bool IgnoreEmptyClassPaths = false {product} {default}
bool IgnoreUnrecognizedVMOptions = false {product} {default}
uintx IncreaseFirstTierCompileThresholdAt = 50 {product} {default}
bool IncrementalInline = true {C2 product} {default}
uintx InitialCodeCacheSize = 2555904 {pd product} {default}
size_t InitialHeapSize = 262144000 {product} {ergonomic}
uintx InitialRAMFraction = 64 {product} {default}
double InitialRAMPercentage = 1.562500 {product} {default}
uintx InitialSurvivorRatio = 8 {product} {default}
uintx InitialTenuringThreshold = 7 {product} {default}
uintx InitiatingHeapOccupancyPercent = 45 {product} {default}
bool Inline = true {product} {default}
ccstr InlineDataFile = {product} {default}
intx InlineSmallCode = 1000 {C2 pd product} {default}
bool InlineSynchronizedMethods = true {C1 product} {default}
intx InteriorEntryAlignment = 16 {C2 pd product} {default}
intx InterpreterProfilePercentage = 33 {product} {default}
uint JVMCICompilerIdleDelay = 1000 {JVMCI product} {default}
intx JVMCICounterSize = 0 {JVMCI product} {default}
bool JVMCICountersExcludeCompiler = true {JVMCI product} {default}
intx JVMCIEventLogLevel = 1 {JVMCI product} {default}
ccstr JVMCILibDumpJNIConfig = {JVMCI product} {default}
ccstr JVMCILibPath = {JVMCI product} {default}
intx JVMCINMethodSizeLimit = 655360 {JVMCI product} {default}
ccstr JVMCINativeLibraryErrorFile = {JVMCI product} {default}
bool JVMCIPrintProperties = false {JVMCI product} {default}
intx JVMCIThreads = 1 {JVMCI product} {default}
uint JVMCIThreadsPerNativeLibraryRuntime = 0 {JVMCI product} {default}
intx JVMCITraceLevel = 0 {JVMCI product} {default}
bool JavaMonitorsInStackTrace = true {product} {default}
intx JavaPriority10_To_OSPriority = -1 {product} {default}
intx JavaPriority1_To_OSPriority = -1 {product} {default}
intx JavaPriority2_To_OSPriority = -1 {product} {default}
intx JavaPriority3_To_OSPriority = -1 {product} {default}
intx JavaPriority4_To_OSPriority = -1 {product} {default}
intx JavaPriority5_To_OSPriority = -1 {product} {default}
intx JavaPriority6_To_OSPriority = -1 {product} {default}
intx JavaPriority7_To_OSPriority = -1 {product} {default}
intx JavaPriority8_To_OSPriority = -1 {product} {default}
intx JavaPriority9_To_OSPriority = -1 {product} {default}
size_t LargePageHeapSizeThreshold = 134217728 {product} {default}
size_t LargePageSizeInBytes = 0 {product} {default}
intx LiveNodeCountInliningCutoff = 40000 {C2 product} {default}
bool LoadExecStackDllInVMThread = true {product} {default}
intx LoopMaxUnroll = 16 {C2 product} {default}
intx LoopOptsCount = 43 {C2 product} {default}
intx LoopPercentProfileLimit = 10 {C2 pd product} {default}
uintx LoopStripMiningIter = 1000 {C2 product} {default}
uintx LoopStripMiningIterShortLoop = 100 {C2 product} {default}
intx LoopUnrollLimit = 60 {C2 pd product} {default}
intx LoopUnrollMin = 4 {C2 product} {default}
bool LoopUnswitching = true {C2 product} {default}
bool ManagementServer = false {product} {default}
size_t MarkStackSize = 4194304 {product} {ergonomic}
size_t MarkStackSizeMax = 536870912 {product} {default}
uint MarkSweepAlwaysCompactCount = 4 {product} {default}
uintx MarkSweepDeadRatio = 5 {product} {default}
intx MaxBCEAEstimateLevel = 5 {product} {default}
intx MaxBCEAEstimateSize = 150 {product} {default}
uint64_t MaxDirectMemorySize = 0 {product} {default}
bool MaxFDLimit = true {product} {default}
uintx MaxGCMinorPauseMillis = 18446744073709551615 {product} {default}
uintx MaxGCPauseMillis = 200 {product} {default}
uintx MaxHeapFreeRatio = 70 {manageable} {default}
size_t MaxHeapSize = 4169138176 {product} {ergonomic}
intx MaxInlineLevel = 15 {C2 product} {default}
intx MaxInlineSize = 35 {C2 product} {default}
intx MaxJNILocalCapacity = 65536 {product} {default}
intx MaxJavaStackTraceDepth = 1024 {product} {default}
intx MaxJumpTableSize = 65000 {C2 product} {default}
intx MaxJumpTableSparseness = 5 {C2 product} {default}
intx MaxLabelRootDepth = 1100 {C2 product} {default}
intx MaxLoopPad = 11 {C2 product} {default}
size_t MaxMetaspaceExpansion = 5439488 {product} {default}
uintx MaxMetaspaceFreeRatio = 70 {product} {default}
size_t MaxMetaspaceSize = 18446744073709551615 {product} {default}
size_t MaxNewSize = 2499805184 {product} {ergonomic}
intx MaxNodeLimit = 80000 {C2 product} {default}
uint64_t MaxRAM = 137438953472 {pd product} {default}
uintx MaxRAMFraction = 4 {product} {default}
double MaxRAMPercentage = 25.000000 {product} {default}
intx MaxRecursiveInlineLevel = 1 {C2 product} {default}
uintx MaxTenuringThreshold = 15 {product} {default}
intx MaxTrivialSize = 6 {C2 product} {default}
intx MaxVectorSize = 32 {C2 product} {default}
ccstr MetaspaceReclaimPolicy = balanced {product} {default}
size_t MetaspaceSize = 22020096 {product} {default}
bool MethodFlushing = true {product} {default}
size_t MinHeapDeltaBytes = 2097152 {product} {ergonomic}
uintx MinHeapFreeRatio = 40 {manageable} {default}
size_t MinHeapSize = 8388608 {product} {ergonomic}
intx MinInliningThreshold = 250 {product} {default}
intx MinJumpTableSize = 10 {C2 pd product} {default}
size_t MinMetaspaceExpansion = 327680 {product} {default}
uintx MinMetaspaceFreeRatio = 40 {product} {default}
uintx MinRAMFraction = 2 {product} {default}
double MinRAMPercentage = 50.000000 {product} {default}
uintx MinSurvivorRatio = 3 {product} {default}
size_t MinTLABSize = 2048 {product} {default}
intx MultiArrayExpandLimit = 6 {C2 product} {default}
uintx NUMAChunkResizeWeight = 20 {product} {default}
size_t NUMAInterleaveGranularity = 2097152 {product} {default}
uintx NUMAPageScanRate = 256 {product} {default}
size_t NUMASpaceResizeRate = 1073741824 {product} {default}
bool NUMAStats = false {product} {default}
ccstr NativeMemoryTracking = off {product} {default}
bool NeverActAsServerClassMachine = false {pd product} {default}
bool NeverTenure = false {product} {default}
uintx NewRatio = 2 {product} {default}
size_t NewSize = 1363144 {product} {default}
size_t NewSizeThreadIncrease = 5320 {pd product} {default}
intx NmethodSweepActivity = 10 {product} {default}
intx NodeLimitFudgeFactor = 2000 {C2 product} {default}
uintx NonNMethodCodeHeapSize = 5839372 {pd product} {ergonomic}
uintx NonProfiledCodeHeapSize = 122909434 {pd product} {ergonomic}
intx NumberOfLoopInstrToAlign = 4 {C2 product} {default}
intx ObjectAlignmentInBytes = 8 {product lp64_product} {default}
size_t OldPLABSize = 1024 {product} {default}
size_t OldSize = 5452592 {product} {default}
bool OmitStackTraceInFastThrow = true {product} {default}
ccstrlist OnError = {product} {default}
ccstrlist OnOutOfMemoryError = {product} {default}
intx OnStackReplacePercentage = 140 {pd product} {default}
bool OptimizeFill = false {C2 product} {default}
bool OptimizePtrCompare = true {C2 product} {default}
bool OptimizeStringConcat = true {C2 product} {default}
bool OptoBundling = false {C2 pd product} {default}
intx OptoLoopAlignment = 16 {pd product} {default}
bool OptoRegScheduling = true {C2 pd product} {default}
bool OptoScheduling = false {C2 pd product} {default}
uintx PLABWeight = 75 {product} {default}
bool PSChunkLargeArrays = true {product} {default}
int ParGCArrayScanChunk = 50 {product} {default}
uintx ParallelGCBufferWastePct = 10 {product} {default}
uint ParallelGCThreads = 8 {product} {default}
size_t ParallelOldDeadWoodLimiterMean = 50 {product} {default}
size_t ParallelOldDeadWoodLimiterStdDev = 80 {product} {default}
bool ParallelRefProcBalancingEnabled = true {product} {default}
bool ParallelRefProcEnabled = true {product} {default}
bool PartialPeelAtUnsignedTests = true {C2 product} {default}
bool PartialPeelLoop = true {C2 product} {default}
intx PartialPeelNewPhiDelta = 0 {C2 product} {default}
uintx PausePadding = 1 {product} {default}
intx PerBytecodeRecompilationCutoff = 200 {product} {default}
intx PerBytecodeTrapLimit = 4 {product} {default}
intx PerMethodRecompilationCutoff = 400 {product} {default}
intx PerMethodTrapLimit = 100 {product} {default}
bool PerfAllowAtExitRegistration = false {product} {default}
bool PerfBypassFileSystemCheck = false {product} {default}
intx PerfDataMemorySize = 32768 {product} {default}
intx PerfDataSamplingInterval = 50 {product} {default}
ccstr PerfDataSaveFile = {product} {default}
bool PerfDataSaveToFile = false {product} {default}
bool PerfDisableSharedMem = false {product} {default}
intx PerfMaxStringConstLength = 1024 {product} {default}
size_t PreTouchParallelChunkSize = 4194304 {pd product} {default}
bool PreferContainerQuotaForCPUCount = true {product} {default}
bool PreferInterpreterNativeStubs = false {pd product} {default}
intx PrefetchCopyIntervalInBytes = 576 {product} {default}
intx PrefetchFieldsAhead = 1 {product} {default}
intx PrefetchScanIntervalInBytes = 576 {product} {default}
bool PreserveAllAnnotations = false {product} {default}
bool PreserveFramePointer = false {pd product} {default}
size_t PretenureSizeThreshold = 0 {product} {default}
bool PrintClassHistogram = false {manageable} {default}
bool PrintCodeCache = false {product} {default}
bool PrintCodeCacheOnCompilation = false {product} {default}
bool PrintCommandLineFlags = false {product} {default}
bool PrintCompilation = false {product} {default}
bool PrintConcurrentLocks = false {manageable} {default}
bool PrintExtendedThreadInfo = false {product} {default}
bool PrintFlagsFinal = true {product} {command line}
bool PrintFlagsInitial = false {product} {default}
bool PrintFlagsRanges = false {product} {default}
bool PrintGC = false {product} {default}
bool PrintGCDetails = false {product} {default}
bool PrintHeapAtSIGBREAK = true {product} {default}
bool PrintSharedArchiveAndExit = false {product} {default}
bool PrintSharedDictionary = false {product} {default}
bool PrintStringTableStatistics = false {product} {default}
bool PrintTieredEvents = false {product} {default}
bool PrintVMOptions = false {product} {default}
bool PrintWarnings = true {product} {default}
uintx ProcessDistributionStride = 4 {product} {default}
bool ProfileInterpreter = true {pd product} {default}
intx ProfileMaturityPercentage = 20 {product} {default}
uintx ProfiledCodeHeapSize = 122909434 {pd product} {ergonomic}
uintx PromotedPadding = 3 {product} {default}
uintx QueuedAllocationWarningCount = 0 {product} {default}
int RTMRetryCount = 5 {ARCH product} {default}
bool RangeCheckElimination = true {product} {default}
bool ReassociateInvariants = true {C2 product} {default}
bool RecordDynamicDumpInfo = false {product} {default}
bool ReduceBulkZeroing = true {C2 product} {default}
bool ReduceFieldZeroing = true {C2 product} {default}
bool ReduceInitialCardMarks = true {C2 product} {default}
bool ReduceSignalUsage = false {product} {default}
intx RefDiscoveryPolicy = 0 {product} {default}
bool RegisterFinalizersAtInit = true {product} {default}
bool RelaxAccessControlCheck = false {product} {default}
ccstr ReplayDataFile = {product} {default}
bool RequireSharedSpaces = false {product} {default}
uintx ReservedCodeCacheSize = 251658240 {pd product} {ergonomic}
bool ResizePLAB = true {product} {default}
bool ResizeTLAB = true {product} {default}
bool RestoreMXCSROnJNICalls = false {product} {default}
bool RestrictContended = true {product} {default}
bool RestrictReservedStack = true {product} {default}
bool RewriteBytecodes = true {pd product} {default}
bool RewriteFrequentPairs = true {pd product} {default}
bool SafepointTimeout = false {product} {default}
intx SafepointTimeoutDelay = 10000 {product} {default}
bool ScavengeBeforeFullGC = false {product} {default}
bool SegmentedCodeCache = true {product} {ergonomic}
intx SelfDestructTimer = 0 {product} {default}
ccstr SharedArchiveConfigFile = {product} {default}
ccstr SharedArchiveFile = {product} {default}
size_t SharedBaseAddress = 34359738368 {product} {default}
ccstr SharedClassListFile = {product} {default}
uintx SharedSymbolTableBucketSize = 4 {product} {default}
bool ShowCodeDetailsInExceptionMessages = true {manageable} {default}
bool ShowMessageBoxOnError = false {product} {default}
bool ShrinkHeapInSteps = true {product} {default}
size_t SoftMaxHeapSize = 4169138176 {manageable} {ergonomic}
intx SoftRefLRUPolicyMSPerMB = 1000 {product} {default}
bool SplitIfBlocks = true {C2 product} {default}
intx StackRedPages = 1 {pd product} {default}
intx StackReservedPages = 1 {pd product} {default}
intx StackShadowPages = 20 {pd product} {default}
bool StackTraceInThrowable = true {product} {default}
intx StackYellowPages = 2 {pd product} {default}
uintx StartAggressiveSweepingAt = 10 {product} {default}
bool StartAttachListener = false {product} {default}
ccstr StartFlightRecording = {product} {default}
uint StringDeduplicationAgeThreshold = 3 {product} {default}
uintx StringTableSize = 65536 {product} {default}
bool SuperWordLoopUnrollAnalysis = true {C2 pd product} {default}
bool SuperWordReductions = true {C2 product} {default}
bool SuppressFatalErrorMessage = false {product} {default}
uintx SurvivorPadding = 3 {product} {default}
uintx SurvivorRatio = 8 {product} {default}
double SweeperThreshold = 0.500000 {product} {default}
uintx TLABAllocationWeight = 35 {product} {default}
uintx TLABRefillWasteFraction = 64 {product} {default}
size_t TLABSize = 0 {product} {default}
bool TLABStats = true {product} {default}
uintx TLABWasteIncrement = 4 {product} {default}
uintx TLABWasteTargetPercent = 1 {product} {default}
uintx TargetPLABWastePct = 10 {product} {default}
uintx TargetSurvivorRatio = 50 {product} {default}
uintx TenuredGenerationSizeIncrement = 20 {product} {default}
uintx TenuredGenerationSizeSupplement = 80 {product} {default}
uintx TenuredGenerationSizeSupplementDecay = 2 {product} {default}
intx ThreadPriorityPolicy = 1 {product} {jimage}
bool ThreadPriorityVerbose = false {product} {default}
intx ThreadStackSize = 1024 {pd product} {default}
uintx ThresholdTolerance = 10 {product} {default}
intx Tier0BackedgeNotifyFreqLog = 10 {product} {default}
intx Tier0InvokeNotifyFreqLog = 7 {product} {default}
intx Tier0ProfilingStartPercentage = 200 {product} {default}
intx Tier23InlineeNotifyFreqLog = 20 {product} {default}
intx Tier2BackEdgeThreshold = 0 {product} {default}
intx Tier2BackedgeNotifyFreqLog = 14 {product} {default}
intx Tier2CompileThreshold = 0 {product} {default}
intx Tier2InvokeNotifyFreqLog = 11 {product} {default}
intx Tier3BackEdgeThreshold = 60000 {product} {default}
intx Tier3BackedgeNotifyFreqLog = 13 {product} {default}
intx Tier3CompileThreshold = 2000 {product} {default}
intx Tier3DelayOff = 2 {product} {default}
intx Tier3DelayOn = 5 {product} {default}
intx Tier3InvocationThreshold = 200 {product} {default}
intx Tier3InvokeNotifyFreqLog = 10 {product} {default}
intx Tier3LoadFeedback = 5 {product} {default}
intx Tier3MinInvocationThreshold = 100 {product} {default}
intx Tier4BackEdgeThreshold = 40000 {product} {default}
intx Tier4CompileThreshold = 15000 {product} {default}
intx Tier4InvocationThreshold = 5000 {product} {default}
intx Tier4LoadFeedback = 3 {product} {default}
intx Tier4MinInvocationThreshold = 600 {product} {default}
bool TieredCompilation = true {pd product} {default}
intx TieredCompileTaskTimeout = 50 {product} {default}
intx TieredRateUpdateMaxTime = 25 {product} {default}
intx TieredRateUpdateMinTime = 1 {product} {default}
intx TieredStopAtLevel = 4 {product} {default}
bool TimeLinearScan = false {C1 product} {default}
ccstr TraceJVMTI = {product} {default}
intx TrackedInitializationLimit = 50 {C2 product} {default}
bool TrapBasedNullChecks = false {pd product} {default}
bool TrapBasedRangeChecks = false {C2 pd product} {default}
intx TypeProfileArgsLimit = 2 {product} {default}
uintx TypeProfileLevel = 0 {pd product} {default}
intx TypeProfileMajorReceiverPercent = 90 {C2 product} {default}
intx TypeProfileParmsLimit = 2 {product} {default}
intx TypeProfileWidth = 8 {product} {default}
intx UnguardOnExecutionViolation = 0 {product} {default}
bool UseAES = true {product} {default}
intx UseAVX = 2 {ARCH product} {default}
bool UseAdaptiveGenerationSizePolicyAtMajorCollection = true {product} {default}
bool UseAdaptiveGenerationSizePolicyAtMinorCollection = true {product} {default}
bool UseAdaptiveNUMAChunkSizing = true {product} {default}
bool UseAdaptiveSizeDecayMajorGCCost = true {product} {default}
bool UseAdaptiveSizePolicy = true {product} {default}
bool UseAdaptiveSizePolicyFootprintGoal = true {product} {default}
bool UseAdaptiveSizePolicyWithSystemGC = false {product} {default}
bool UseAddressNop = true {ARCH product} {default}
bool UseBASE64Intrinsics = false {product} {default}
bool UseBMI1Instructions = true {ARCH product} {default}
bool UseBMI2Instructions = true {ARCH product} {default}
bool UseBiasedLocking = false {product} {default}
bool UseBimorphicInlining = true {C2 product} {default}
bool UseCLMUL = true {ARCH product} {default}
bool UseCMoveUnconditionally = false {C2 product} {default}
bool UseCodeAging = true {product} {default}
bool UseCodeCacheFlushing = true {product} {default}
bool UseCompiler = true {product} {default}
bool UseCompressedClassPointers = true {product lp64_product} {ergonomic}
bool UseCompressedOops = true {product lp64_product} {ergonomic}
bool UseCondCardMark = false {product} {default}
bool UseContainerSupport = true {product} {default}
bool UseCountLeadingZerosInstruction = true {ARCH product} {default}
bool UseCountTrailingZerosInstruction = true {ARCH product} {default}
bool UseCountedLoopSafepoints = true {C2 product} {default}
bool UseCounterDecay = true {product} {default}
bool UseDivMod = true {C2 product} {default}
bool UseDynamicNumberOfCompilerThreads = true {product} {default}
bool UseDynamicNumberOfGCThreads = true {product} {default}
bool UseEmptySlotsInSupers = true {product} {default}
bool UseFMA = true {product} {default}
bool UseFPUForSpilling = true {C2 product} {default}
bool UseFastJNIAccessors = true {product} {default}
bool UseFastStosb = false {ARCH product} {default}
bool UseG1GC = true {product} {ergonomic}
bool UseGCOverheadLimit = true {product} {default}
bool UseHeavyMonitors = false {product} {default}
bool UseHugeTLBFS = false {product} {default}
bool UseInlineCaches = true {product} {default}
bool UseInterpreter = true {product} {default}
bool UseJVMCICompiler = true {JVMCI product} {default}
bool UseJVMCINativeLibrary = true {JVMCI product} {default}
bool UseJumpTables = true {C2 product} {default}
bool UseLargePages = false {pd product} {default}
bool UseLargePagesIndividualAllocation = false {pd product} {default}
bool UseLinuxPosixThreadCPUClocks = true {product} {default}
bool UseLoopCounter = true {product} {default}
bool UseLoopInvariantCodeMotion = true {C1 product} {default}
bool UseLoopPredicate = true {C2 product} {default}
bool UseMaximumCompactionOnSystemGC = true {product} {default}
bool UseNUMA = false {product} {default}
bool UseNUMAInterleaving = false {product} {default}
bool UseNewLongLShift = false {ARCH product} {default}
bool UseNotificationThread = true {product} {default}
bool UseOnStackReplacement = true {pd product} {default}
bool UseOnlyInlinedBimorphic = true {C2 product} {default}
bool UseOprofile = false {product} {default}
bool UseOptoBiasInlining = false {C2 product} {default}
bool UsePSAdaptiveSurvivorSizePolicy = true {product} {default}
bool UseParallelGC = false {product} {default}
bool UsePerfData = true {product} {default}
bool UsePopCountInstruction = true {product} {default}
bool UseProfiledLoopPredicate = true {C2 product} {default}
bool UseRTMDeopt = false {ARCH product} {default}
bool UseRTMLocking = false {ARCH product} {default}
bool UseSHA = true {product} {default}
bool UseSHM = false {product} {default}
intx UseSSE = 4 {ARCH product} {default}
bool UseSSE42Intrinsics = true {ARCH product} {default}
bool UseSerialGC = false {product} {default}
bool UseSharedSpaces = true {product} {default}
bool UseShenandoahGC = false {product} {default}
bool UseSignalChaining = true {product} {default}
bool UseStoreImmI16 = false {ARCH product} {default}
bool UseStringDeduplication = false {product} {default}
bool UseSubwordForMaxVector = true {C2 product} {default}
bool UseSuperWord = true {C2 product} {default}
bool UseTLAB = true {product} {default}
bool UseThreadPriorities = true {pd product} {default}
bool UseTransparentHugePages = false {product} {default}
bool UseTypeProfile = true {product} {default}
bool UseTypeSpeculation = true {C2 product} {default}
bool UseUnalignedLoadStores = true {ARCH product} {default}
bool UseVectorCmov = false {C2 product} {default}
bool UseXMMForArrayCopy = true {product} {default}
bool UseXMMForObjInit = true {ARCH product} {default}
bool UseXmmI2D = false {ARCH product} {default}
bool UseXmmI2F = false {ARCH product} {default}
bool UseXmmLoadAndClearUpper = true {ARCH product} {default}
bool UseXmmRegToRegMoveAll = true {ARCH product} {default}
bool UseZGC = false {product} {default}
intx VMThreadPriority = -1 {product} {default}
intx VMThreadStackSize = 1024 {pd product} {default}
intx ValueMapInitialSize = 11 {C1 product} {default}
intx ValueMapMaxLoopSize = 8 {C1 product} {default}
intx ValueSearchLimit = 1000 {C2 product} {default}
bool VerifySharedSpaces = false {product} {default}
uintx YoungGenerationSizeIncrement = 20 {product} {default}
uintx YoungGenerationSizeSupplement = 80 {product} {default}
uintx YoungGenerationSizeSupplementDecay = 8 {product} {default}
size_t YoungPLABSize = 4096 {product} {default}
double ZAllocationSpikeTolerance = 2.000000 {product} {default}
double ZCollectionInterval = 0.000000 {product} {default}
double ZFragmentationLimit = 25.000000 {product} {default}
size_t ZMarkStackSpaceLimit = 8589934592 {product} {default}
bool ZProactive = true {product} {default}
bool ZUncommit = true {product} {default}
uintx ZUncommitDelay = 300 {product} {default}
bool ZeroTLAB = false {product} {default}
openjdk version "17.0.4" 2022-07-19
OpenJDK Runtime Environment GraalVM CE 22.2.0 (build 17.0.4+8-jvmci-22.2-b06)
OpenJDK 64-Bit Server VM GraalVM CE 22.2.0 (build 17.0.4+8-jvmci-22.2-b06, mixed mode, sharing)