ਵਿਗਿਆਨਕ ਪੋਕ ਵਿਧੀ, ਜਾਂ ਬੈਂਚਮਾਰਕ ਅਤੇ ਇੱਕ ਅਨੁਕੂਲਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਡੇਟਾਬੇਸ ਸੰਰਚਨਾ ਨੂੰ ਕਿਵੇਂ ਚੁਣਨਾ ਹੈ

ਹੈਲੋ

ਮੈਂ ਆਪਣੀ ਖੋਜ ਨੂੰ ਸਾਂਝਾ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ - ਵਿਚਾਰ, ਅਜ਼ਮਾਇਸ਼ ਅਤੇ ਗਲਤੀ ਦਾ ਫਲ।
ਆਮ ਤੌਰ 'ਤੇ: ਇਹ ਕੋਈ ਖੋਜ ਨਹੀਂ ਹੈ, ਬੇਸ਼ੱਕ - ਇਹ ਸਭ ਉਨ੍ਹਾਂ ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਜਾਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਲਾਗੂ ਕੀਤੇ ਅੰਕੜਾ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਕਿਸੇ ਵੀ ਸਿਸਟਮ ਦੇ ਅਨੁਕੂਲਨ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ, ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਕਿ ਖਾਸ ਤੌਰ 'ਤੇ DBMS.
ਅਤੇ: ਹਾਂ, ਉਹ ਜਾਣਦੇ ਹਨ, ਉਹ ਆਪਣੀ ਖੋਜ 'ਤੇ ਦਿਲਚਸਪ ਲੇਖ ਲਿਖਦੇ ਹਨ, ਉਦਾਹਰਨ (UPD.: ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਉਹਨਾਂ ਨੇ ਇੱਕ ਬਹੁਤ ਹੀ ਦਿਲਚਸਪ ਪ੍ਰੋਜੈਕਟ ਵੱਲ ਇਸ਼ਾਰਾ ਕੀਤਾ: ottertune )
ਦੂਜੇ ਪਾਸੇ: ਮੈਂ IT ਮਾਹਿਰਾਂ, DBA ਵਿਚਕਾਰ ਇੰਟਰਨੈੱਟ 'ਤੇ ਇਸ ਪਹੁੰਚ ਦਾ ਕੋਈ ਵਿਆਪਕ ਜ਼ਿਕਰ ਜਾਂ ਪ੍ਰਸਾਰ ਨਹੀਂ ਦੇਖਦਾ।

ਇਸ ਲਈ, ਬਿੰਦੂ ਤੱਕ.

ਚਲੋ ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਕੰਮ ਹੈ: ਕਿਸੇ ਕਿਸਮ ਦੇ ਕੰਮ ਦੀ ਸੇਵਾ ਲਈ ਇੱਕ ਖਾਸ ਸੇਵਾ ਪ੍ਰਣਾਲੀ ਸਥਾਪਤ ਕਰਨਾ।

ਇਸ ਕੰਮ ਬਾਰੇ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ: ਇਹ ਕੀ ਹੈ, ਇਸ ਕੰਮ ਦੀ ਗੁਣਵੱਤਾ ਕਿਵੇਂ ਮਾਪੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਗੁਣਵੱਤਾ ਨੂੰ ਮਾਪਣ ਲਈ ਮਾਪਦੰਡ ਕੀ ਹੈ.

ਚਲੋ ਇਹ ਵੀ ਮੰਨ ਲਓ ਕਿ ਇਹ ਘੱਟ ਜਾਂ ਘੱਟ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ: ਇਸ ਸੇਵਾ ਪ੍ਰਣਾਲੀ ਵਿੱਚ (ਜਾਂ ਨਾਲ) ਕੰਮ ਕਿਵੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

“ਵੱਧ ਜਾਂ ਘੱਟ” - ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਕ ਖਾਸ ਟੂਲ, ਉਪਯੋਗਤਾ, ਸੇਵਾ ਤਿਆਰ ਕਰਨਾ (ਜਾਂ ਇਸਨੂੰ ਕਿਤੇ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ) ਸੰਭਵ ਹੈ ਜਿਸ ਨੂੰ ਸੰਸਲੇਸ਼ਣ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇੱਕ ਟੈਸਟ ਲੋਡ ਦੇ ਨਾਲ ਸਿਸਟਮ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਉਤਪਾਦਨ ਵਿੱਚ ਹੋਣ ਵਾਲੇ ਲਈ ਕਾਫ਼ੀ ਹੈ, ਉਤਪਾਦਨ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਸਥਿਤੀਆਂ ਵਿੱਚ.

ਖੈਰ, ਮੰਨ ਲਓ ਕਿ ਇਸ ਸੇਵਾ ਪ੍ਰਣਾਲੀ ਲਈ ਸਮਾਯੋਜਨ ਮਾਪਦੰਡਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸਦੀ ਵਰਤੋਂ ਇਸ ਸਿਸਟਮ ਨੂੰ ਇਸਦੇ ਕੰਮ ਦੀ ਉਤਪਾਦਕਤਾ ਦੇ ਰੂਪ ਵਿੱਚ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਅਤੇ ਸਮੱਸਿਆ ਕੀ ਹੈ - ਇਸ ਸੇਵਾ ਪ੍ਰਣਾਲੀ ਦੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਸਮਝ ਨਹੀਂ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਕਿਸੇ ਦਿੱਤੇ ਪਲੇਟਫਾਰਮ 'ਤੇ ਭਵਿੱਖ ਦੇ ਲੋਡ ਲਈ ਇਸ ਸਿਸਟਮ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਨੂੰ ਮਾਹਰਤਾ ਨਾਲ ਕੌਂਫਿਗਰ ਕਰਨ ਅਤੇ ਸਿਸਟਮ ਦੀ ਲੋੜੀਂਦੀ ਉਤਪਾਦਕਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਖੈਰ। ਇਹ ਲਗਭਗ ਹਮੇਸ਼ਾ ਕੇਸ ਹੁੰਦਾ ਹੈ.

ਤੁਸੀਂ ਇੱਥੇ ਕੀ ਕਰ ਸਕਦੇ ਹੋ?

ਖੈਰ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜੋ ਦਿਮਾਗ ਵਿੱਚ ਆਉਂਦਾ ਹੈ ਉਹ ਹੈ ਇਸ ਸਿਸਟਮ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਵੇਖਣਾ. ਸਮਝੋ ਕਿ ਐਡਜਸਟਮੈਂਟ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਲਈ ਸਵੀਕਾਰਯੋਗ ਰੇਂਜ ਕੀ ਹਨ। ਅਤੇ, ਉਦਾਹਰਨ ਲਈ, ਕੋਆਰਡੀਨੇਟ ਡਿਸੈਂਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਟੈਸਟਾਂ ਵਿੱਚ ਸਿਸਟਮ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਮੁੱਲ ਚੁਣੋ।

ਉਹ. ਸਿਸਟਮ ਨੂੰ ਕਿਸੇ ਕਿਸਮ ਦੀ ਸੰਰਚਨਾ ਦਿਓ, ਇਸਦੇ ਸੰਰਚਨਾ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਖਾਸ ਸੈੱਟ ਦੇ ਰੂਪ ਵਿੱਚ।

ਇਸ ਬਹੁਤ ਹੀ ਟੂਲ-ਯੂਟਿਲਿਟੀ, ਲੋਡ ਜਨਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇਸ 'ਤੇ ਇੱਕ ਟੈਸਟ ਲੋਡ ਲਾਗੂ ਕਰੋ।
ਅਤੇ ਮੁੱਲ ਨੂੰ ਦੇਖੋ - ਜਵਾਬ, ਜਾਂ ਸਿਸਟਮ ਦੀ ਗੁਣਵੱਤਾ ਦਾ ਇੱਕ ਮੈਟ੍ਰਿਕ.

ਦੂਜਾ ਵਿਚਾਰ ਇਹ ਸਿੱਟਾ ਕੱਢ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਬਹੁਤ ਲੰਬਾ ਸਮਾਂ ਹੈ.

ਖੈਰ, ਉਹ ਇਹ ਹੈ: ਜੇਕਰ ਬਹੁਤ ਸਾਰੇ ਮਾਪਦੰਡ ਮਾਪਦੰਡ ਹਨ, ਜੇਕਰ ਉਹਨਾਂ ਦੇ ਚੱਲ ਰਹੇ ਮੁੱਲਾਂ ਦੀਆਂ ਰੇਂਜਾਂ ਵੱਡੀਆਂ ਹਨ, ਜੇਕਰ ਹਰੇਕ ਵਿਅਕਤੀਗਤ ਲੋਡ ਟੈਸਟ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਤਾਂ: ਹਾਂ, ਇਹ ਸਭ ਕੁਝ ਅਸਵੀਕਾਰਨਯੋਗ ਰੂਪ ਵਿੱਚ ਲੈ ਸਕਦਾ ਹੈ ਲੰਬਾ ਸਮਾ.

ਖੈਰ, ਇੱਥੇ ਉਹ ਹੈ ਜੋ ਤੁਸੀਂ ਸਮਝ ਅਤੇ ਯਾਦ ਕਰ ਸਕਦੇ ਹੋ।

ਤੁਸੀਂ ਇਹ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹੋ ਕਿ ਸੇਵਾ ਸਿਸਟਮ ਸੈਟਿੰਗਾਂ ਦੇ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਦੇ ਸੈੱਟ ਵਿੱਚ ਇੱਕ ਵੈਕਟਰ ਹੁੰਦਾ ਹੈ, ਕੁਝ ਮੁੱਲਾਂ ਦੇ ਕ੍ਰਮ ਵਜੋਂ.

ਹਰੇਕ ਅਜਿਹੇ ਵੈਕਟਰ, ਹੋਰ ਚੀਜ਼ਾਂ ਬਰਾਬਰ ਹੋਣ (ਇਸ ਵਿੱਚ ਇਹ ਇਸ ਵੈਕਟਰ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦਾ), ਮੈਟ੍ਰਿਕ ਦੇ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਿਸ਼ਚਿਤ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ - ਇੱਕ ਟੈਸਟ ਲੋਡ ਦੇ ਅਧੀਨ ਸਿਸਟਮ ਦੇ ਸੰਚਾਲਨ ਦੀ ਗੁਣਵੱਤਾ ਦਾ ਸੂਚਕ।

ਅਰਥਾਤ

ਆਉ ਅਸੀਂ ਸਿਸਟਮ ਕੌਂਫਿਗਰੇਸ਼ਨ ਵੈਕਟਰ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦਰਸਾਉਂਦੇ ਹਾਂ ਕਿੱਥੇ ; ਜਿੱਥੇ — ਸਿਸਟਮ ਸੰਰਚਨਾ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਗਿਣਤੀ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿੰਨੇ ਪੈਰਾਮੀਟਰ ਹਨ।

ਅਤੇ ਇਸ ਨਾਲ ਸੰਬੰਧਿਤ ਮੈਟ੍ਰਿਕ ਦਾ ਮੁੱਲ ਆਓ ਇਸ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦਰਸਾ ਦੇਈਏ
, ਫਿਰ ਸਾਨੂੰ ਫੰਕਸ਼ਨ ਮਿਲਦਾ ਹੈ:

ਖੈਰ, ਫਿਰ: ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਸਭ ਕੁਝ ਤੁਰੰਤ ਹੇਠਾਂ ਆ ਜਾਂਦਾ ਹੈ: ਮੇਰੇ ਵਿਦਿਆਰਥੀ ਦਿਨਾਂ ਤੋਂ ਲਗਭਗ ਭੁੱਲ ਗਿਆ, ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਸੀਮਾ ਦੀ ਖੋਜ ਲਈ ਐਲਗੋਰਿਦਮ।

ਠੀਕ ਹੈ, ਪਰ ਇੱਥੇ ਇੱਕ ਸੰਗਠਨਾਤਮਕ ਅਤੇ ਲਾਗੂ ਸਵਾਲ ਉੱਠਦਾ ਹੈ: ਕਿਹੜਾ ਐਲਗੋਰਿਦਮ ਵਰਤਣਾ ਹੈ।

1. ਅਰਥ ਵਿਚ - ਤਾਂ ਜੋ ਤੁਸੀਂ ਹੱਥ ਨਾਲ ਘੱਟ ਕੋਡ ਕਰ ਸਕੋ.
2. ਅਤੇ ਇਸ ਨੂੰ ਕੰਮ ਕਰਨ ਲਈ, i.e. ਐਕਸਟ੍ਰੀਮਮ (ਜੇ ਕੋਈ ਹੈ) ਲੱਭਿਆ ਹੈ, ਠੀਕ ਹੈ, ਘੱਟੋ-ਘੱਟ ਤਾਲਮੇਲ ਉਤਰਨ ਨਾਲੋਂ ਤੇਜ਼।

ਪਹਿਲਾ ਬਿੰਦੂ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ ਕਿ ਸਾਨੂੰ ਕੁਝ ਵਾਤਾਵਰਣਾਂ ਵੱਲ ਵੇਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜਿਸ ਵਿੱਚ ਅਜਿਹੇ ਐਲਗੋਰਿਦਮ ਪਹਿਲਾਂ ਹੀ ਲਾਗੂ ਕੀਤੇ ਜਾ ਚੁੱਕੇ ਹਨ, ਅਤੇ, ਕਿਸੇ ਰੂਪ ਵਿੱਚ, ਕੋਡ ਵਿੱਚ ਵਰਤੋਂ ਲਈ ਤਿਆਰ ਹਨ।
ਨਾਲ ਨਾਲ, ਮੈਨੂੰ ਪਤਾ ਹੈ python и cran-r

ਦੂਜੇ ਨੁਕਤੇ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਐਲਗੋਰਿਦਮ ਬਾਰੇ ਆਪਣੇ ਆਪ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਹੈ, ਉਹ ਕੀ ਹਨ, ਉਹਨਾਂ ਦੀਆਂ ਲੋੜਾਂ ਕੀ ਹਨ, ਉਹਨਾਂ ਦੇ ਕੰਮ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ.

ਅਤੇ ਜੋ ਉਹ ਦਿੰਦੇ ਹਨ ਉਹ ਲਾਭਦਾਇਕ ਮਾੜੇ ਪ੍ਰਭਾਵ ਹੋ ਸਕਦੇ ਹਨ - ਨਤੀਜੇ, ਜਾਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਐਲਗੋਰਿਦਮ ਤੋਂ.

ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਐਲਗੋਰਿਦਮ ਦੇ ਨਤੀਜਿਆਂ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.

ਬਹੁਤ ਕੁਝ ਇੰਪੁੱਟ ਸ਼ਰਤਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ, ਕਿਸੇ ਕਾਰਨ ਕਰਕੇ, ਤੁਹਾਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਠੀਕ ਹੈ, ਤੁਹਾਨੂੰ ਗਰੇਡੀਐਂਟ ਡਿਸੈਂਟ ਐਲਗੋਰਿਦਮ ਵੱਲ ਧਿਆਨ ਦੇਣ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਚੁਣਨ ਦੀ ਲੋੜ ਹੈ।

ਜਾਂ, ਜੇਕਰ ਸਮਾਂ ਇੰਨਾ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ, ਉਦਾਹਰਨ ਲਈ, ਸਟੋਚੈਸਟਿਕ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਵਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਜੈਨੇਟਿਕ ਐਲਗੋਰਿਦਮ।

ਮੈਂ ਇਸ ਪਹੁੰਚ ਦੇ ਕੰਮ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰਦਾ ਹਾਂ, ਸਿਸਟਮ ਕੌਂਫਿਗਰੇਸ਼ਨ ਦੀ ਚੋਣ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਜੈਨੇਟਿਕ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਗਲੇ ਵਿੱਚ, ਇਸ ਲਈ ਬੋਲਣ ਲਈ: ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਦਾ ਕੰਮ.

ਮੂਲ:

1. ਇੱਕ ਸੇਵਾ ਪ੍ਰਣਾਲੀ ਦੇ ਰੂਪ ਵਿੱਚ, ਇੱਥੇ ਹੋਣ ਦਿਓ: oracle xe 18c
2. ਇਸਨੂੰ ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਗਤੀਵਿਧੀ ਅਤੇ ਟੀਚਾ ਪੂਰਾ ਕਰਨ ਦਿਓ: ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ/ਸੈਕੰਡ ਵਿੱਚ, ਸਬ-ਡੇਟਾਬੇਸ ਦਾ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਵ ਥ੍ਰਰੂਪੁਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ।
3. ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਤੀ ਅਤੇ ਕੰਮ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਲੈਣ-ਦੇਣ ਬਹੁਤ ਵੱਖਰੇ ਹੋ ਸਕਦੇ ਹਨ।
   ਆਓ ਸਹਿਮਤ ਕਰੀਏ ਕਿ ਇਹ ਉਹ ਲੈਣ-ਦੇਣ ਹਨ ਜੋ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਟੇਬਲਯੂਲਰ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਕਰਦੇ ਹਨ।
   ਇਸ ਅਰਥ ਵਿਚ ਕਿ ਉਹ ਰੀਡੂ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਅਨਡੂ ਡੇਟਾ ਨਹੀਂ ਬਣਾਉਂਦੇ ਅਤੇ ਕਤਾਰਾਂ ਅਤੇ ਵੱਡੀਆਂ ਟੇਬਲਾਂ ਦੇ ਵੱਡੇ ਪ੍ਰਤੀਸ਼ਤ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਕਰਦੇ ਹਨ।

ਇਹ ਉਹ ਲੈਣ-ਦੇਣ ਹਨ ਜੋ ਇਸ ਸਾਰਣੀ 'ਤੇ ਥੋੜ੍ਹੇ ਜਿਹੇ ਸੂਚਕਾਂਕ ਦੇ ਨਾਲ, ਘੱਟ ਜਾਂ ਵੱਡੀ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਕਤਾਰ ਨੂੰ ਬਦਲਦੇ ਹਨ।

ਇਸ ਸਥਿਤੀ ਵਿੱਚ: ਪ੍ਰੋਸੈਸਿੰਗ ਲੈਣ-ਦੇਣ ਲਈ ਸਬ-ਡੇਟਾਬੇਸ ਦੀ ਉਤਪਾਦਕਤਾ, ਇੱਕ ਰਿਜ਼ਰਵੇਸ਼ਨ ਦੇ ਨਾਲ, ਰੀਡੌਕਸ ਡੇਟਾਬੇਸ ਦੁਆਰਾ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਗੁਣਵੱਤਾ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਵੇਗੀ।

ਬੇਦਾਅਵਾ - ਜੇਕਰ ਅਸੀਂ ਖਾਸ ਤੌਰ 'ਤੇ ਸਬਡੀਬੀ ਸੈਟਿੰਗਾਂ ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਹਾਂ।

ਕਿਉਂਕਿ, ਆਮ ਸਥਿਤੀ ਵਿੱਚ, ਟੇਬਲਯੂਲਰ ਡੇਟਾ ਅਤੇ/ਜਾਂ ਟੇਬਿਊਲਰ ਮਾਡਲ ਦੇ ਨਾਲ ਉਪਭੋਗਤਾ ਦੇ ਕੰਮ ਦੇ ਡਿਜ਼ਾਈਨ ਦੇ ਕਾਰਨ, ਉਦਾਹਰਨ ਲਈ, SQL ਸੈਸ਼ਨਾਂ ਵਿਚਕਾਰ ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਲਾਕ ਹੋ ਸਕਦੇ ਹਨ।

ਜਿਸਦਾ, ਬੇਸ਼ੱਕ, TPS ਮੈਟ੍ਰਿਕ 'ਤੇ ਇੱਕ ਨਿਰਾਸ਼ਾਜਨਕ ਪ੍ਰਭਾਵ ਹੋਵੇਗਾ ਅਤੇ ਇਹ ਸਬ-ਡੇਟਾਬੇਸ ਦੇ ਅਨੁਸਾਰੀ ਇੱਕ ਬਾਹਰੀ ਕਾਰਕ ਹੋਵੇਗਾ: ਠੀਕ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਟੇਬਲ ਮਾਡਲ ਨੂੰ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਇਸ ਵਿੱਚ ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਜੋ ਰੁਕਾਵਟਾਂ ਹੁੰਦੀਆਂ ਹਨ।

ਇਸ ਲਈ, ਪ੍ਰਯੋਗ ਦੀ ਸ਼ੁੱਧਤਾ ਲਈ, ਅਸੀਂ ਇਸ ਕਾਰਕ ਨੂੰ ਬਾਹਰ ਰੱਖਾਂਗੇ, ਅਤੇ ਹੇਠਾਂ ਮੈਂ ਸਪਸ਼ਟ ਕਰਾਂਗਾ ਕਿ ਕਿਵੇਂ.

1. ਨਿਸ਼ਚਿਤਤਾ ਲਈ, ਅਸੀਂ ਮੰਨ ਲੈਂਦੇ ਹਾਂ ਕਿ ਡੇਟਾਬੇਸ ਵਿੱਚ ਜਮ੍ਹਾਂ ਕੀਤੀਆਂ SQL ਕਮਾਂਡਾਂ ਵਿੱਚੋਂ 100% DML ਕਮਾਂਡਾਂ ਹਨ।
   ਸਬ-ਡੇਟਾਬੇਸ ਦੇ ਨਾਲ ਉਪਭੋਗਤਾ ਦੇ ਕੰਮ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਟੈਸਟਾਂ ਵਿੱਚ ਇੱਕੋ ਜਿਹਾ ਹੋਣ ਦਿਓ।
   ਅਰਥਾਤ: skl ਸੈਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ, ਸਾਰਣੀਬੱਧ ਡੇਟਾ, skl ਸੈਸ਼ਨ ਉਹਨਾਂ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।
2. ਸਬਡ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ FORCE LOGGING, ARCHIVELOG ਮੋਡ ਫਲੈਸ਼ਬੈਕ-ਡਾਟਾਬੇਸ ਮੋਡ ਬੰਦ ਹੈ, ਸਬ-ਡ ਪੱਧਰ 'ਤੇ।
3. ਰੀਡੋ ਲੌਗਸ: ਇੱਕ ਵੱਖਰੇ ਫਾਈਲ ਸਿਸਟਮ ਵਿੱਚ ਸਥਿਤ, ਇੱਕ ਵੱਖਰੀ “ਡਿਸਕ” ਉੱਤੇ;
   ਡੇਟਾਬੇਸ ਦਾ ਬਾਕੀ ਭੌਤਿਕ ਭਾਗ: ਇੱਕ ਹੋਰ ਵਿੱਚ, ਵੱਖਰੇ ਫਾਈਲ ਸਿਸਟਮ ਵਿੱਚ, ਇੱਕ ਵੱਖਰੀ “ਡਿਸਕ” ਉੱਤੇ:

ਭੌਤਿਕ ਯੰਤਰ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ। ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਡਾਟਾਬੇਸ ਹਿੱਸੇ

SQL> select status||' '||name from v$controlfile;
 /db/u14/oradata/XE/control01.ctl
SQL> select GROUP#||' '||MEMBER from v$logfile;
1 /db/u02/oradata/XE/redo01_01.log
2 /db/u02/oradata/XE/redo02_01.log
SQL> select FILE_ID||' '||TABLESPACE_NAME||' '||round(BYTES/1024/1024,2)||' '||FILE_NAME as col from dba_data_files;
4 UNDOTBS1 2208 /db/u14/oradata/XE/undotbs1_01.dbf
2 SLOB 128 /db/u14/oradata/XE/slob01.dbf
7 USERS 5 /db/u14/oradata/XE/users01.dbf
1 SYSTEM 860 /db/u14/oradata/XE/system01.dbf
3 SYSAUX 550 /db/u14/oradata/XE/sysaux01.dbf
5 MONITOR 128 /db/u14/oradata/XE/monitor.dbf
SQL> !cat /proc/mounts | egrep "/db/u[0-2]"
/dev/vda1 /db/u14 ext4 rw,noatime,nodiratime,data=ordered 0 0
/dev/mapper/vgsys-ora_redo /db/u02 xfs rw,noatime,nodiratime,attr2,nobarrier,inode64,logbsize=256k,noquota 0 0

ਸ਼ੁਰੂ ਵਿੱਚ, ਇਹਨਾਂ ਲੋਡ ਹਾਲਤਾਂ ਵਿੱਚ, ਮੈਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਸਬਡੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ SLOB- ਉਪਯੋਗਤਾ
ਇਸਦੀ ਇੱਕ ਸ਼ਾਨਦਾਰ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ, ਮੈਂ ਲੇਖਕ ਦਾ ਹਵਾਲਾ ਦੇਵਾਂਗਾ:

SLOB ਦੇ ਕੇਂਦਰ ਵਿੱਚ "SLOB ਵਿਧੀ" ਹੈ। SLOB ਵਿਧੀ ਦਾ ਉਦੇਸ਼ ਪਲੇਟਫਾਰਮਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਹੈ
ਅਰਜ਼ੀ ਦੇ ਵਿਵਾਦ ਤੋਂ ਬਿਨਾਂ। ਕੋਈ ਵੱਧ ਤੋਂ ਵੱਧ ਹਾਰਡਵੇਅਰ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਨਹੀਂ ਚਲਾ ਸਕਦਾ
ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਜੋ ਕਿ, ਉਦਾਹਰਨ ਲਈ, ਐਪਲੀਕੇਸ਼ਨ ਲੌਕਿੰਗ ਦੁਆਰਾ ਬੰਨ੍ਹਿਆ ਹੋਇਆ ਹੈ ਜਾਂ ਵੀ
ਓਰੇਕਲ ਡੇਟਾਬੇਸ ਬਲਾਕਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਨਾ. ਇਹ ਸਹੀ ਹੈ — ਡਾਟਾ ਸਾਂਝਾ ਕਰਨ ਵੇਲੇ ਓਵਰਹੈੱਡ ਹੁੰਦਾ ਹੈ
ਡਾਟਾ ਬਲਾਕਾਂ ਵਿੱਚ! ਪਰ SLOB - ਇਸਦੀ ਡਿਫੌਲਟ ਤੈਨਾਤੀ ਵਿੱਚ - ਅਜਿਹੇ ਵਿਵਾਦ ਤੋਂ ਮੁਕਤ ਹੈ।

ਇਹ ਘੋਸ਼ਣਾ: ਮੇਲ ਖਾਂਦਾ ਹੈ, ਇਹ ਹੈ।
cl ਸੈਸ਼ਨਾਂ ਦੀ ਸਮਾਨਤਾ ਦੀ ਡਿਗਰੀ ਨੂੰ ਨਿਯੰਤ੍ਰਿਤ ਕਰਨਾ ਸੁਵਿਧਾਜਨਕ ਹੈ, ਇਹ ਕੁੰਜੀ ਹੈ -t ਸਹੂਲਤ ਨੂੰ ਸ਼ੁਰੂ ਕਰੋ runit.sh SLOB ਤੋਂ
DML ਕਮਾਂਡਾਂ ਦੀ ਪ੍ਰਤੀਸ਼ਤਤਾ ਨਿਯੰਤ੍ਰਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਸਬਡ ਨੂੰ ਭੇਜੇ ਗਏ ਟੈਕਸਟ ਸੁਨੇਹਿਆਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ, ਹਰੇਕ ਟੈਕਸਟ ਸੈਸ਼ਨ, ਪੈਰਾਮੀਟਰ UPDATE_PCT
ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਅਤੇ ਬਹੁਤ ਹੀ ਸੁਵਿਧਾਜਨਕ: SLOB ਆਪਣੇ ਆਪ, ਲੋਡ ਸੈਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ - ਇੱਕ ਸਟੈਟਸਪੈਕ, ਜਾਂ awr-ਸਨੈਪਸ਼ਾਟ ਤਿਆਰ ਕਰਦਾ ਹੈ (ਕੀ ਤਿਆਰ ਕਰਨ ਲਈ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ)।

ਹਾਲਾਂਕਿ, ਇਹ ਸਾਹਮਣੇ ਆਇਆ ਹੈ ਕਿ SLOB 30 ਸਕਿੰਟਾਂ ਤੋਂ ਘੱਟ ਦੀ ਮਿਆਦ ਵਾਲੇ SQL ਸੈਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ।
ਇਸ ਲਈ, ਮੈਂ ਪਹਿਲਾਂ ਲੋਡਰ ਦਾ ਆਪਣਾ, ਮਜ਼ਦੂਰ-ਕਿਸਾਨ ਸੰਸਕਰਣ ਕੋਡ ਕੀਤਾ, ਅਤੇ ਫਿਰ ਇਹ ਕਾਰਜਸ਼ੀਲ ਰਿਹਾ।

ਮੈਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨ ਦਿਓ ਕਿ ਲੋਡਰ ਕੀ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕਰਦਾ ਹੈ, ਸਪਸ਼ਟਤਾ ਲਈ।
ਅਸਲ ਵਿੱਚ ਲੋਡਰ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਦਾ ਹੈ:

ਵਰਕਰ ਕੋਡ

function dotx()
{
local v_period="$2"
[ -z "v_period" ] && v_period="0"
source "/home/oracle/testingredotracе/config.conf"

$ORACLE_HOME/bin/sqlplus -S system/${v_system_pwd} << __EOF__
whenever sqlerror exit failure
set verify off
set echo off
set feedback off

define wnum="$1"
define period="$v_period"
set appinfo worker_&&wnum

declare
 v_upto number;
 v_key  number;
 v_tots number;
 v_cts  number;
begin
 select max(col1) into v_upto from system.testtab_&&wnum;
 SELECT (( SYSDATE - DATE '1970-01-01' ) * 86400 ) into v_cts FROM DUAL;
 v_tots := &&period + v_cts;
 while v_cts <= v_tots
 loop
  v_key:=abs(mod(dbms_random.random,v_upto));
  if v_key=0 then
   v_key:=1;
  end if;
  update system.testtab_&&wnum t
  set t.object_name=translate(dbms_random.string('a', 120), 'abcXYZ', '158249')
  where t.col1=v_key
  ;
  commit;
  SELECT (( SYSDATE - DATE '1970-01-01' ) * 86400 ) into v_cts FROM DUAL;
 end loop;
end;
/

exit
__EOF__
}
export -f dotx

ਵਰਕਰਾਂ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

ਚੱਲ ਰਹੇ ਵਰਕਰ

echo "starting test, duration: ${TEST_DURATION}" >> "$v_logfile"
for((i=1;i<="$SQLSESS_COUNT";i++))
do
 echo "sql-session: ${i}" >> "$v_logfile"
 dotx "$i" "${TEST_DURATION}" &
done
echo "waiting..." >> "$v_logfile"
wait

ਅਤੇ ਕਾਮਿਆਂ ਲਈ ਟੇਬਲ ਇਸ ਤਰ੍ਹਾਂ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ:

ਟੇਬਲ ਬਣਾਉਣਾ

function createtable() {
source "/home/oracle/testingredotracе/config.conf"
$ORACLE_HOME/bin/sqlplus -S system/${v_system_pwd} << __EOF__
whenever sqlerror continue
set verify off
set echo off
set feedback off

define wnum="$1"
define ts_name="slob"

begin
 execute immediate 'drop table system.testtab_&&wnum';
exception when others then null;
end;
/

create table system.testtab_&&wnum tablespace &&ts_name as
select rownum as col1, t.*
from sys.dba_objects t
where rownum<1000
;
create index testtab_&&wnum._idx on system.testtab_&&wnum (col1);
--alter table system.testtab_&&wnum nologging;
--alter index system.testtab_&&wnum._idx nologging;
exit
__EOF__
}
export -f createtable

seq 1 1 "$SQLSESS_COUNT" | xargs -n 1 -P 4 -I {} -t bash -c "createtable "{}"" | tee -a "$v_logfile"
echo "createtable done" >> "$v_logfile"

ਉਹ. ਹਰੇਕ ਵਰਕਰ ਲਈ (ਅਮਲੀ ਤੌਰ 'ਤੇ: DB ਵਿੱਚ ਇੱਕ ਵੱਖਰਾ SQL ਸੈਸ਼ਨ) ਇੱਕ ਵੱਖਰੀ ਸਾਰਣੀ ਬਣਾਈ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਕਰਮਚਾਰੀ ਕੰਮ ਕਰਦਾ ਹੈ।

ਇਹ ਕਰਮਚਾਰੀ ਸੈਸ਼ਨਾਂ ਵਿਚਕਾਰ ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਲਾਕ ਦੀ ਅਣਹੋਂਦ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।
ਹਰ ਵਰਕਰ: ਉਹੀ ਕੰਮ ਕਰਦਾ ਹੈ, ਆਪਣੇ ਮੇਜ਼ ਨਾਲ, ਮੇਜ਼ ਸਾਰੇ ਇੱਕੋ ਜਿਹੇ ਹਨ।
ਸਾਰੇ ਕਰਮਚਾਰੀ ਇੱਕੋ ਸਮੇਂ ਲਈ ਕੰਮ ਕਰਦੇ ਹਨ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕਾਫ਼ੀ ਲੰਬੇ ਸਮੇਂ ਲਈ ਤਾਂ ਕਿ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਲੌਗ ਸਵਿੱਚ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਵਾਪਰੇਗਾ, ਅਤੇ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ.
ਖੈਰ, ਇਸਦੇ ਅਨੁਸਾਰ, ਸੰਬੰਧਿਤ ਲਾਗਤਾਂ ਅਤੇ ਪ੍ਰਭਾਵ ਪੈਦਾ ਹੋਏ.
ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਮੈਂ ਵਰਕਰਾਂ ਦੇ ਕੰਮ ਦੀ ਮਿਆਦ 8 ਮਿੰਟਾਂ 'ਤੇ ਕੌਂਫਿਗਰ ਕੀਤੀ।

ਇੱਕ ਸਟੈਟਸਪੈਕ ਰਿਪੋਰਟ ਦਾ ਇੱਕ ਟੁਕੜਾ ਲੋਡ ਅਧੀਨ ਸਬਡੀ ਦੇ ਸੰਚਾਲਨ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ

Database    DB Id    Instance     Inst Num  Startup Time   Release     RAC
~~~~~~~~ ----------- ------------ -------- --------------- ----------- ---
          2929910313 XE                  1 07-Sep-20 23:12 18.0.0.0.0  NO

Host Name             Platform                CPUs Cores Sockets   Memory (G)
~~~~ ---------------- ---------------------- ----- ----- ------- ------------
     billing.izhevsk1 Linux x86 64-bit           2     2       1         15.6

Snapshot       Snap Id     Snap Time      Sessions Curs/Sess Comment
~~~~~~~~    ---------- ------------------ -------- --------- ------------------
Begin Snap:       1630 07-Sep-20 23:12:27       55        .7
  End Snap:       1631 07-Sep-20 23:20:29       62        .6
   Elapsed:       8.03 (mins) Av Act Sess:       8.4
   DB time:      67.31 (mins)      DB CPU:      15.01 (mins)

Cache Sizes            Begin        End
~~~~~~~~~~~       ---------- ----------
    Buffer Cache:     1,392M              Std Block Size:         8K
     Shared Pool:       288M                  Log Buffer:   103,424K

Load Profile              Per Second    Per Transaction    Per Exec    Per Call
~~~~~~~~~~~~      ------------------  ----------------- ----------- -----------
      DB time(s):                8.4                0.0        0.00        0.20
       DB CPU(s):                1.9                0.0        0.00        0.04
       Redo size:        7,685,765.6              978.4
   Logical reads:           60,447.0                7.7
   Block changes:           47,167.3                6.0
  Physical reads:                8.3                0.0
 Physical writes:              253.4                0.0
      User calls:               42.6                0.0
          Parses:               23.2                0.0
     Hard parses:                1.2                0.0
W/A MB processed:                1.0                0.0
          Logons:                0.5                0.0
        Executes:           15,756.5                2.0
       Rollbacks:                0.0                0.0
    Transactions:            7,855.1

ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਦੇ ਕੰਮ 'ਤੇ ਵਾਪਸ ਜਾਣਾ.
ਅਸੀਂ, ਹੋਰ ਚੀਜ਼ਾਂ ਬਰਾਬਰ ਹੋਣ ਕਰਕੇ, ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਸਬ-ਡੇਟਾਬੇਸ ਦੇ ਹੇਠਲੇ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲਾਂਗੇ:

1. ਡਾਟਾਬੇਸ ਲਾਗ ਸਮੂਹਾਂ ਦਾ ਆਕਾਰ। ਮੁੱਲ ਸੀਮਾ: [32, 1024] MB;
2. ਡੇਟਾਬੇਸ ਵਿੱਚ ਜਰਨਲ ਸਮੂਹਾਂ ਦੀ ਸੰਖਿਆ। ਮੁੱਲ ਸੀਮਾ: [2,32];
3. log_archive_max_processes ਮੁੱਲ ਸੀਮਾ: [1,8];
4. commit_logging ਦੋ ਮੁੱਲ ਦੀ ਇਜਾਜ਼ਤ ਹੈ: batch|immediate;
5. commit_wait ਦੋ ਮੁੱਲ ਦੀ ਇਜਾਜ਼ਤ ਹੈ: wait|nowait;
6. log_buffer ਮੁੱਲ ਸੀਮਾ: [2,128] MB।
7. log_checkpoint_timeout ਮੁੱਲ ਸੀਮਾ: [60,1200] ਸਕਿੰਟ
8. db_writer_processes ਮੁੱਲ ਸੀਮਾ: [1,4]
9. undo_retention ਮੁੱਲ ਸੀਮਾ: [30;300] ਸਕਿੰਟ
10. transactions_per_rollback_segment ਮੁੱਲ ਸੀਮਾ: [1,8]
11. disk_asynch_io ਦੋ ਮੁੱਲ ਦੀ ਇਜਾਜ਼ਤ ਹੈ: true|false;
12. filesystemio_options ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲਾਂ ਦੀ ਇਜਾਜ਼ਤ ਹੈ: none|setall|directIO|asynch;
13. db_block_checking ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲਾਂ ਦੀ ਇਜਾਜ਼ਤ ਹੈ: OFF|LOW|MEDIUM|FULL;
14. db_block_checksum ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲਾਂ ਦੀ ਇਜਾਜ਼ਤ ਹੈ: OFF|TYPICAL|FULL;

ਓਰੇਕਲ ਡੇਟਾਬੇਸ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਦਾ ਤਜਰਬਾ ਰੱਖਣ ਵਾਲਾ ਵਿਅਕਤੀ ਨਿਸ਼ਚਤ ਤੌਰ 'ਤੇ ਪਹਿਲਾਂ ਹੀ ਕਹਿ ਸਕਦਾ ਹੈ ਕਿ ਕੀ ਅਤੇ ਕਿਹੜੇ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ, ਨਿਰਧਾਰਤ ਮਾਪਦੰਡਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਸਵੀਕਾਰਯੋਗ ਮੁੱਲਾਂ ਤੋਂ, ਡੇਟਾਬੇਸ ਦੁਆਰਾ ਦਰਸਾਏ ਗਏ ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਲਈ ਡੇਟਾਬੇਸ ਦੀ ਵਧੇਰੇ ਉਤਪਾਦਕਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ. ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ, ਇੱਥੇ ਉੱਪਰ।

ਪਰ.

ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਦੇ ਕੰਮ ਦਾ ਬਿੰਦੂ ਇਹ ਦਰਸਾਉਣਾ ਹੈ ਕਿ ਆਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਸਾਡੇ ਲਈ ਮੁਕਾਬਲਤਨ ਤੇਜ਼ੀ ਨਾਲ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੇਗਾ.

ਸਾਡੇ ਲਈ, ਜੋ ਕੁਝ ਬਚਿਆ ਹੈ, ਉਹ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਵੇਖਣਾ ਹੈ, ਅਨੁਕੂਲਿਤ ਪ੍ਰਣਾਲੀ ਦੁਆਰਾ, ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਾਫ਼ੀ ਹੈ ਕਿ ਕਿਹੜੇ ਮਾਪਦੰਡ ਬਦਲਣੇ ਹਨ ਅਤੇ ਕਿਹੜੀਆਂ ਰੇਂਜਾਂ ਵਿੱਚ.
ਅਤੇ ਇਹ ਵੀ: ਕੋਡ ਕੋਡ ਜੋ ਚੁਣੇ ਹੋਏ ਅਨੁਕੂਲਨ ਐਲਗੋਰਿਦਮ ਦੇ ਕਸਟਮ ਸਿਸਟਮ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਇਸ ਲਈ, ਹੁਣ ਕੋਡ ਬਾਰੇ.
ਮੈਂ ਉੱਪਰ ਗੱਲ ਕੀਤੀ ਹੈ cran-r, ਅਰਥਾਤ: ਕਸਟਮਾਈਜ਼ਡ ਸਿਸਟਮ ਨਾਲ ਸਾਰੀਆਂ ਹੇਰਾਫੇਰੀਆਂ ਨੂੰ ਇੱਕ ਆਰ ਸਕ੍ਰਿਪਟ ਦੇ ਰੂਪ ਵਿੱਚ ਆਰਕੇਸਟ੍ਰੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਅਸਲ ਕੰਮ, ਵਿਸ਼ਲੇਸ਼ਣ, ਮੀਟ੍ਰਿਕ ਮੁੱਲ ਦੁਆਰਾ ਚੋਣ, ਸਿਸਟਮ ਸਟੇਟ ਵੈਕਟਰ: ਇਹ ਇੱਕ ਪੈਕੇਜ ਹੈ GA (ਦਸਤਾਵੇਜ਼)
ਪੈਕੇਜ, ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਬਹੁਤ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ, ਇਸ ਅਰਥ ਵਿੱਚ ਕਿ ਇਹ ਵੈਕਟਰਾਂ (ਕ੍ਰੋਮੋਸੋਮਜ਼, ਜੇ ਪੈਕੇਜ ਦੇ ਰੂਪ ਵਿੱਚ) ਨੂੰ ਇੱਕ ਫ੍ਰੈਕਸ਼ਨਲ ਹਿੱਸੇ ਦੇ ਨਾਲ ਨੰਬਰਾਂ ਦੀਆਂ ਤਾਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਣ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ।

ਅਤੇ ਮੇਰਾ ਵੈਕਟਰ, ਸੈਟਿੰਗ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਤੋਂ: ਇਹ 14 ਮਾਤਰਾਵਾਂ ਹਨ - ਪੂਰਨ ਅੰਕ ਅਤੇ ਸਤਰ ਮੁੱਲ।

ਸਮੱਸਿਆ, ਬੇਸ਼ੱਕ, ਸਤਰ ਮੁੱਲਾਂ ਨੂੰ ਕੁਝ ਖਾਸ ਸੰਖਿਆਵਾਂ ਨਿਰਧਾਰਤ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਟਾਲਿਆ ਜਾਂਦਾ ਹੈ।

ਇਸ ਤਰ੍ਹਾਂ, ਅੰਤ ਵਿੱਚ, ਆਰ ਸਕ੍ਰਿਪਟ ਦਾ ਮੁੱਖ ਹਿੱਸਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

GA::ga ਨੂੰ ਕਾਲ ਕਰੋ

cat( "", file=v_logfile, sep="n", append=F)

pSize = 10
elitism_value=1
pmutation_coef=0.8
pcrossover_coef=0.1
iterations=50

gam=GA::ga(type="real-valued", fitness=evaluate,
lower=c(32,2, 1,1,1,2,60,1,30,1,0,0, 0,0), upper=c(1024,32, 8,10,10,128,800,4,300,8,10,40, 40,30),
popSize=pSize,
pcrossover = pcrossover_coef,
pmutation = pmutation_coef,
maxiter=iterations,
run=4,
keepBest=T)
cat( "GA-session is done" , file=v_logfile, sep="n", append=T)
gam@solution

ਇੱਥੇ, ਮਦਦ ਨਾਲ lower и upper ਸਬਰੂਟੀਨ ਗੁਣ ga ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ, ਖੋਜ ਸਪੇਸ ਦਾ ਇੱਕ ਖੇਤਰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜਿਸ ਦੇ ਅੰਦਰ ਅਜਿਹੇ ਵੈਕਟਰ (ਜਾਂ ਵੈਕਟਰ) ਲਈ ਖੋਜ ਕੀਤੀ ਜਾਵੇਗੀ ਜਿਸ ਲਈ ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਦਾ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਵੇਗਾ।

ga ਸਬਰੂਟੀਨ ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਖੋਜ ਕਰਦਾ ਹੈ।

ਖੈਰ, ਫਿਰ, ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ, ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ, ਸਬਡ ਦੇ ਕੁਝ ਮਾਪਦੰਡਾਂ ਲਈ ਵੈਕਟਰ ਨੂੰ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਵਜੋਂ ਸਮਝਦਾ ਹੈ, ਸਬਡ ਤੋਂ ਇੱਕ ਮੈਟ੍ਰਿਕ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।

ਇਹ ਹੈ: ਕਿੰਨੇ, ਦਿੱਤੇ ਗਏ ਸਬ-ਡੀ ਸੈੱਟਅੱਪ ਅਤੇ ਸਬ-ਡੀ 'ਤੇ ਦਿੱਤੇ ਲੋਡ ਦੇ ਨਾਲ: ਸਬ-ਡੀ ਪ੍ਰਤੀ ਸਕਿੰਟ ਲੈਣ-ਦੇਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ।

ਭਾਵ, ਜਦੋਂ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਹੇਠਾਂ ਦਿੱਤੇ ਬਹੁ-ਪੜਾਅ ਨੂੰ ਪੂਰਾ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ:

1. ਸੰਖਿਆਵਾਂ ਦੇ ਇਨਪੁਟ ਵੈਕਟਰ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ - ਇਸਨੂੰ ਸਬ-ਡਾਟਾ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਮੁੱਲਾਂ ਵਿੱਚ ਬਦਲਣਾ।
2. ਦਿੱਤੇ ਆਕਾਰ ਦੇ ਰੀਡੋ ਸਮੂਹਾਂ ਦੀ ਇੱਕ ਦਿੱਤੀ ਸੰਖਿਆ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕੋਸ਼ਿਸ਼ ਅਸਫਲ ਹੋ ਸਕਦੀ ਹੈ।
   ਪ੍ਰਯੋਗ ਦੀ ਸ਼ੁੱਧਤਾ ਲਈ, ਮੈਗਜ਼ੀਨ ਸਮੂਹ ਜੋ ਪਹਿਲਾਂ ਹੀ ਸਬਡ ਵਿੱਚ ਮੌਜੂਦ ਸਨ, ਕੁਝ ਮਾਤਰਾ ਵਿੱਚ ਅਤੇ ਕੁਝ ਆਕਾਰ ਦੇ - ਡੀ.ਬੀ. ਹਟਾਇਆ ਗਿਆ।
3. ਜੇਕਰ ਪਿਛਲਾ ਬਿੰਦੂ ਸਫਲ ਹੈ: ਡੇਟਾਬੇਸ ਨੂੰ ਕੌਂਫਿਗਰੇਸ਼ਨ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ (ਦੁਬਾਰਾ: ਇੱਕ ਅਸਫਲਤਾ ਹੋ ਸਕਦੀ ਹੈ)
4. ਜੇਕਰ ਪਿਛਲਾ ਪੜਾਅ ਸਫਲ ਹੁੰਦਾ ਹੈ: ਸਬਡੀ ਨੂੰ ਰੋਕਣਾ, ਸਬਡੀ ਸ਼ੁਰੂ ਕਰਨਾ ਤਾਂ ਕਿ ਨਵੇਂ ਨਿਰਧਾਰਤ ਪੈਰਾਮੀਟਰ ਮੁੱਲ ਪ੍ਰਭਾਵੀ ਹੋਣ। (ਦੁਬਾਰਾ: ਕੋਈ ਗੜਬੜ ਹੋ ਸਕਦੀ ਹੈ)
5. ਜੇਕਰ ਪਿਛਲਾ ਕਦਮ ਸਫਲ ਹੈ: ਇੱਕ ਲੋਡ ਟੈਸਟ ਕਰੋ। subd ਤੋਂ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਾਪਤ ਕਰੋ।
6. ਸਬਡ ਨੂੰ ਇਸਦੀ ਅਸਲ ਸਥਿਤੀ ਵਿੱਚ ਵਾਪਸ ਕਰੋ, ਯਾਨੀ. ਵਾਧੂ ਲਾਗ ਸਮੂਹਾਂ ਨੂੰ ਮਿਟਾਓ, ਕੰਮ ਕਰਨ ਲਈ ਮੂਲ ਸਬ-ਡਾਟਾਬੇਸ ਸੰਰਚਨਾ ਨੂੰ ਵਾਪਸ ਕਰੋ।

ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਕੋਡ

evaluate=function(p_par) {
v_module="evaluate"
v_metric=0
opn=NULL
opn$rg_size=round(p_par[1],digit=0)
opn$rg_count=round(p_par[2],digit=0)
opn$log_archive_max_processes=round(p_par[3],digit=0)
opn$commit_logging="BATCH"
if ( round(p_par[4],digit=0) > 5 ) {
 opn$commit_logging="IMMEDIATE"
}
opn$commit_logging=paste("'", opn$commit_logging, "'",sep="")

opn$commit_wait="WAIT"
if ( round(p_par[5],digit=0) > 5 ) {
 opn$commit_wait="NOWAIT"
}
opn$commit_wait=paste("'", opn$commit_wait, "'",sep="")

opn$log_buffer=paste(round(p_par[6],digit=0),"m",sep="")
opn$log_checkpoint_timeout=round(p_par[7],digit=0)
opn$db_writer_processes=round(p_par[8],digit=0)
opn$undo_retention=round(p_par[9],digit=0)
opn$transactions_per_rollback_segment=round(p_par[10],digit=0)
opn$disk_asynch_io="true"
if ( round(p_par[11],digit=0) > 5 ) {
 opn$disk_asynch_io="false"
} 

opn$filesystemio_options="none"
if ( round(p_par[12],digit=0) > 10 && round(p_par[12],digit=0) <= 20 ) {
 opn$filesystemio_options="setall"
}
if ( round(p_par[12],digit=0) > 20 && round(p_par[12],digit=0) <= 30 ) {
 opn$filesystemio_options="directIO"
}
if ( round(p_par[12],digit=0) > 30 ) {
 opn$filesystemio_options="asynch"
}

opn$db_block_checking="OFF"
if ( round(p_par[13],digit=0) > 10 && round(p_par[13],digit=0) <= 20 ) {
 opn$db_block_checking="LOW"
}
if ( round(p_par[13],digit=0) > 20 && round(p_par[13],digit=0) <= 30 ) {
 opn$db_block_checking="MEDIUM"
}
if ( round(p_par[13],digit=0) > 30 ) {
 opn$db_block_checking="FULL"
}

opn$db_block_checksum="OFF"
if ( round(p_par[14],digit=0) > 10 && round(p_par[14],digit=0) <= 20 ) {
 opn$db_block_checksum="TYPICAL"
}
if ( round(p_par[14],digit=0) > 20 ) {
 opn$db_block_checksum="FULL"
}

v_vector=paste(round(p_par[1],digit=0),round(p_par[2],digit=0),round(p_par[3],digit=0),round(p_par[4],digit=0),round(p_par[5],digit=0),round(p_par[6],digit=0),round(p_par[7],digit=0),round(p_par[8],digit=0),round(p_par[9],digit=0),round(p_par[10],digit=0),round(p_par[11],digit=0),round(p_par[12],digit=0),round(p_par[13],digit=0),round(p_par[14],digit=0),sep=";")
cat( paste(v_module," try to evaluate vector: ", v_vector,sep="") , file=v_logfile, sep="n", append=T)

rc=make_additional_rgroups(opn)
if ( rc!=0 ) {
 cat( paste(v_module,"make_additional_rgroups failed",sep="") , file=v_logfile, sep="n", append=T)
 return (0)
}

v_rc=0
rc=set_db_parameter("log_archive_max_processes", opn$log_archive_max_processes)
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("commit_logging", opn$commit_logging )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("commit_wait", opn$commit_wait )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("log_buffer", opn$log_buffer )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("log_checkpoint_timeout", opn$log_checkpoint_timeout )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("db_writer_processes", opn$db_writer_processes )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("undo_retention", opn$undo_retention )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("transactions_per_rollback_segment", opn$transactions_per_rollback_segment )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("disk_asynch_io", opn$disk_asynch_io )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("filesystemio_options", opn$filesystemio_options )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("db_block_checking", opn$db_block_checking )
if ( rc != 0 ) {  v_rc=1 }
rc=set_db_parameter("db_block_checksum", opn$db_block_checksum )
if ( rc != 0 ) {  v_rc=1 }

if ( rc!=0 ) {
 cat( paste(v_module," can not startup db with that vector of settings",sep="") , file=v_logfile, sep="n", append=T)
 rc=stop_db("immediate")
 rc=create_spfile()
 rc=start_db("")
 rc=remove_additional_rgroups(opn)
 return (0)
}

rc=stop_db("immediate")
rc=start_db("")
if ( rc!=0 ) {
 cat( paste(v_module," can not startup db with that vector of settings",sep="") , file=v_logfile, sep="n", append=T)
 rc=stop_db("abort")
 rc=create_spfile()
 rc=start_db("")
 rc=remove_additional_rgroups(opn)
 return (0)
}

rc=run_test()
v_metric=getmetric()

rc=stop_db("immediate")
rc=create_spfile()
rc=start_db("")
rc=remove_additional_rgroups(opn)

cat( paste("result: ",v_metric," ",v_vector,sep="") , file=v_logfile, sep="n", append=T)
return (v_metric)
}

ਕਿ. ਸਾਰਾ ਕੰਮ: ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਵਿੱਚ ਕੀਤਾ ਗਿਆ।

ਗੈ-ਸਬਰੂਟਾਈਨ ਵੈਕਟਰਾਂ, ਜਾਂ, ਹੋਰ ਸਹੀ ਢੰਗ ਨਾਲ, ਕ੍ਰੋਮੋਸੋਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ।
ਜਿਸ ਵਿੱਚ, ਸਾਡੇ ਲਈ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੀਨਾਂ ਦੇ ਨਾਲ ਕ੍ਰੋਮੋਸੋਮ ਦੀ ਚੋਣ ਜਿਸ ਲਈ ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਵੱਡੇ ਮੁੱਲ ਪੈਦਾ ਕਰਦਾ ਹੈ।

ਇਹ, ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ, ਇੱਕ N-ਅਯਾਮੀ ਖੋਜ ਸਪੇਸ ਵਿੱਚ ਇੱਕ ਵੈਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕ੍ਰੋਮੋਸੋਮਸ ਦੇ ਅਨੁਕੂਲ ਸਮੂਹ ਦੀ ਖੋਜ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹੈ।

ਬਹੁਤ ਸਪੱਸ਼ਟ, ਵਿਸਤ੍ਰਿਤ ਇੱਕ ਸਪੱਸ਼ਟੀਕਰਨ, ਆਰ-ਕੋਡ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ, ਇੱਕ ਜੈਨੇਟਿਕ ਐਲਗੋਰਿਦਮ ਦਾ ਕੰਮ।

ਮੈਂ ਦੋ ਤਕਨੀਕੀ ਨੁਕਤਿਆਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਨੋਟ ਕਰਨਾ ਚਾਹਾਂਗਾ।

ਫੰਕਸ਼ਨ ਤੋਂ ਸਹਾਇਕ ਕਾਲਾਂ evaluate, ਉਦਾਹਰਨ ਲਈ, ਸਟਾਪ-ਸਟਾਰਟ, ਸਬਡ ਪੈਰਾਮੀਟਰ ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ, ਦੇ ਅਧਾਰ ਤੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ cran-r ਫੰਕਸ਼ਨ system2

ਜਿਸ ਦੀ ਮਦਦ ਨਾਲ: ਕੁਝ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਜਾਂ ਕਮਾਂਡ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ:

ਸੈੱਟ_ਡੀਬੀ_ਪੈਰਾਮੀਟਰ

set_db_parameter=function(p1, p2) {
v_module="set_db_parameter"
v_cmd="/home/oracle/testingredotracе/set_db_parameter.sh"
v_args=paste(p1," ",p2,sep="")

x=system2(v_cmd, args=v_args, stdout=T, stderr=T, wait=T)
if ( length(attributes(x)) > 0 ) {
 cat(paste(v_module," failed with: ",attributes(x)$status," ",v_cmd," ",v_args,sep=""), file=v_logfile, sep="n", append=T)
 return (attributes(x)$status)
}
else {
 cat(paste(v_module," ok: ",v_cmd," ",v_args,sep=""), file=v_logfile, sep="n", append=T)
 return (0)
}
}

ਦੂਜਾ ਬਿੰਦੂ ਲਾਈਨ ਹੈ, evaluate ਫੰਕਸ਼ਨ, ਇੱਕ ਖਾਸ ਮੀਟ੍ਰਿਕ ਮੁੱਲ ਅਤੇ ਇਸਦੇ ਅਨੁਸਾਰੀ ਟਿਊਨਿੰਗ ਵੈਕਟਰ ਨੂੰ ਇੱਕ ਲੌਗ ਫਾਈਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਨ ਦੇ ਨਾਲ:

cat( paste("result: ",v_metric," ",v_vector,sep="") , file=v_logfile, sep="n", append=T)

ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕਿਉਂਕਿ ਇਸ ਡੇਟਾ ਐਰੇ ਤੋਂ, ਟਿਊਨਿੰਗ ਵੈਕਟਰ ਦੇ ਕਿਹੜੇ ਭਾਗਾਂ ਦਾ ਮੀਟ੍ਰਿਕ ਮੁੱਲ 'ਤੇ ਜ਼ਿਆਦਾ ਜਾਂ ਘੱਟ ਪ੍ਰਭਾਵ ਹੈ, ਇਸ ਬਾਰੇ ਵਾਧੂ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸੰਭਵ ਹੋਵੇਗਾ।

ਇਹ ਹੈ: ਵਿਸ਼ੇਸ਼ਤਾ-ਅਯਾਤ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ ਸੰਭਵ ਹੋਵੇਗਾ।

ਤਾਂ ਕੀ ਹੋ ਸਕਦਾ ਹੈ?

ਗ੍ਰਾਫ ਦੇ ਰੂਪ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ਵੱਧਦੇ ਮੈਟ੍ਰਿਕ ਕ੍ਰਮ ਵਿੱਚ ਟੈਸਟਾਂ ਦਾ ਆਦੇਸ਼ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤਸਵੀਰ ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ ਹੈ:

ਮੈਟ੍ਰਿਕ ਦੇ ਅਤਿਅੰਤ ਮੁੱਲਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਕੁਝ ਡੇਟਾ:

ਇੱਥੇ, ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ ਸਕਰੀਨਸ਼ਾਟ ਵਿੱਚ, ਮੈਂ ਸਪਸ਼ਟ ਕਰਾਂਗਾ: ਟਿਊਨਿੰਗ ਵੈਕਟਰ ਦੇ ਮੁੱਲ ਫਿਟਨੈਸ ਫੰਕਸ਼ਨ ਕੋਡ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਹਨ, ਨਾ ਕਿ ਪੈਰਾਮੀਟਰ ਮੁੱਲਾਂ ਦੇ ਪੈਰਾਮੀਟਰਾਂ/ਰੇਂਜਾਂ ਦੀ ਸੰਖਿਆ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ, ਜੋ ਕਿ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ। ਪਾਠ ਵਿੱਚ ਉੱਪਰ.

ਖੈਰ। ਕੀ ਇਹ ਬਹੁਤ ਹੈ ਜਾਂ ਥੋੜਾ, ~ 8 ਹਜ਼ਾਰ ਟੀਪੀਐਸ: ਇੱਕ ਵੱਖਰਾ ਸਵਾਲ।
ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਦੇ ਕੰਮ ਦੇ ਢਾਂਚੇ ਦੇ ਅੰਦਰ, ਇਹ ਅੰਕੜਾ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ, ਮਹੱਤਵਪੂਰਨ ਕੀ ਹੈ ਗਤੀਸ਼ੀਲਤਾ ਹੈ, ਇਹ ਮੁੱਲ ਕਿਵੇਂ ਬਦਲਦਾ ਹੈ.

ਇੱਥੇ ਦੀ ਗਤੀਸ਼ੀਲਤਾ ਚੰਗੀ ਹੈ।
ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਕਾਰਕ ਮੈਟ੍ਰਿਕ ਦੇ ਮੁੱਲ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ, ga-ਐਲਗੋਰਿਦਮ, ਕ੍ਰੋਮੋਸੋਮ ਵੈਕਟਰਾਂ ਦੁਆਰਾ ਛਾਂਟਣਾ: ਕਵਰ ਕੀਤਾ ਗਿਆ।
ਕਰਵ ਮੁੱਲਾਂ ਦੀ ਕਾਫ਼ੀ ਜ਼ੋਰਦਾਰ ਗਤੀਸ਼ੀਲਤਾ ਦੁਆਰਾ ਨਿਰਣਾ ਕਰਦੇ ਹੋਏ, ਘੱਟੋ ਘੱਟ ਇੱਕ ਹੋਰ ਕਾਰਕ ਹੈ, ਜੋ ਕਿ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਛੋਟਾ ਹੋਣ ਦੇ ਬਾਵਜੂਦ, ਇੱਕ ਪ੍ਰਭਾਵ ਰੱਖਦਾ ਹੈ।

ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਹੈ attribute-importance ਇਹ ਸਮਝਣ ਲਈ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ ਕਿ ਕਿਹੜੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਟਿਊਨਿੰਗ ਵੈਕਟਰ ਦੇ ਹਿੱਸੇ) ਅਤੇ ਉਹ ਮੀਟ੍ਰਿਕ ਮੁੱਲ ਨੂੰ ਕਿੰਨਾ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ।
ਅਤੇ ਇਸ ਜਾਣਕਾਰੀ ਤੋਂ: ਸਮਝੋ ਕਿ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦੁਆਰਾ ਕਿਹੜੇ ਕਾਰਕ ਪ੍ਰਭਾਵਿਤ ਹੋਏ ਸਨ।

ਚਲਾਓ attribute-importance ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਸੰਭਵ ਹੈ।

ਇਹਨਾਂ ਉਦੇਸ਼ਾਂ ਲਈ, ਮੈਨੂੰ ਐਲਗੋਰਿਦਮ ਪਸੰਦ ਹੈ randomForest ਉਸੇ ਨਾਮ ਦਾ R ਪੈਕੇਜ (ਦਸਤਾਵੇਜ਼)
randomForest, ਜਿਵੇਂ ਕਿ ਮੈਂ ਆਮ ਤੌਰ 'ਤੇ ਉਸਦੇ ਕੰਮ ਨੂੰ ਸਮਝਦਾ ਹਾਂ ਅਤੇ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਮਹੱਤਵ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਉਸਦੀ ਪਹੁੰਚ, ਗੁਣਾਂ 'ਤੇ ਜਵਾਬ ਵੇਰੀਏਬਲ ਦੀ ਨਿਰਭਰਤਾ ਦਾ ਇੱਕ ਖਾਸ ਮਾਡਲ ਬਣਾਉਂਦਾ ਹੈ।

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਜਵਾਬ ਵੇਰੀਏਬਲ ਲੋਡ ਟੈਸਟਾਂ ਵਿੱਚ ਡੇਟਾਬੇਸ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਇੱਕ ਮੈਟ੍ਰਿਕ ਹੈ: tps;
ਅਤੇ ਗੁਣ ਟਿਊਨਿੰਗ ਵੈਕਟਰ ਦੇ ਭਾਗ ਹਨ।

ਇਸ ਲਈ ਇੱਥੇ randomForest ਦੋ ਸੰਖਿਆਵਾਂ ਨਾਲ ਹਰੇਕ ਮਾਡਲ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਮਹੱਤਵ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦਾ ਹੈ: %IncMSE — ਇੱਕ ਮਾਡਲ ਵਿੱਚ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਮੌਜੂਦਗੀ/ਗੈਰ-ਮੌਜੂਦਗੀ ਇਸ ਮਾਡਲ ਦੀ MSE ਗੁਣਵੱਤਾ ਨੂੰ ਕਿਵੇਂ ਬਦਲਦੀ ਹੈ (ਮੀਨ ਵਰਗ ਗਲਤੀ);

ਅਤੇ IncNodePurity ਇੱਕ ਸੰਖਿਆ ਹੈ ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ, ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਮੁੱਲਾਂ ਦੇ ਅਧਾਰ ਤੇ, ਨਿਰੀਖਣਾਂ ਵਾਲੇ ਇੱਕ ਡੇਟਾਸੈਟ ਨੂੰ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ ਜੋ ਇੱਕ ਹਿੱਸੇ ਵਿੱਚ ਮੈਟ੍ਰਿਕ ਦੇ ਇੱਕ ਮੁੱਲ ਦੇ ਨਾਲ ਡੇਟਾ ਹੈ, ਅਤੇ ਦੂਜੇ ਵਿੱਚ ਮੈਟ੍ਰਿਕ ਦਾ ਇੱਕ ਹੋਰ ਮੁੱਲ।
ਖੈਰ, ਇਹ ਹੈ: ਇਹ ਕਿਸ ਹੱਦ ਤੱਕ ਵਰਗੀਕਰਣ ਗੁਣ ਹੈ (ਮੈਂ ਰੈਂਡਮਫੋਰੈਸਟ 'ਤੇ ਸਭ ਤੋਂ ਸਪੱਸ਼ਟ, ਰੂਸੀ-ਭਾਸ਼ਾ ਵਿਆਖਿਆ ਵੇਖੀ ਹੈ। ਇੱਥੇ).

ਲੋਡ ਟੈਸਟਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ ਇੱਕ ਡੇਟਾਸੈਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮਜ਼ਦੂਰ-ਕਿਸਾਨ ਆਰ-ਕੋਡ:

x=NULL
v_data_file=paste('/tmp/data1.dat',sep="")
x=read.table(v_data_file, header = TRUE, sep = ";", dec=",", quote = ""'", stringsAsFactors=FALSE)
colnames(x)=c('metric','rgsize','rgcount','lamp','cmtl','cmtw','lgbffr','lct','dbwrp','undo_retention','tprs','disk_async_io','filesystemio_options','db_block_checking','db_block_checksum')

idxTrain=sample(nrow(x),as.integer(nrow(x)*0.7))
idxNotTrain=which(! 1:nrow(x) %in% idxTrain )
TrainDS=x[idxTrain,]
ValidateDS=x[idxNotTrain,]

library(randomForest)
#mtry=as.integer( sqrt(dim(x)[2]-1) )
rf=randomForest(metric ~ ., data=TrainDS, ntree=40, mtry=3, replace=T, nodesize=2, importance=T, do.trace=10, localImp=F)
ValidateDS$predicted=predict(rf, newdata=ValidateDS[,colnames(ValidateDS)!="metric"], type="response")
sum((ValidateDS$metric-ValidateDS$predicted)^2)
rf$importance

ਤੁਸੀਂ ਆਪਣੇ ਹੱਥਾਂ ਨਾਲ ਐਲਗੋਰਿਦਮ ਦੇ ਹਾਈਪਰਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਚੁਣ ਸਕਦੇ ਹੋ ਅਤੇ, ਮਾਡਲ ਦੀ ਗੁਣਵੱਤਾ 'ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਤ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਮਾਡਲ ਚੁਣ ਸਕਦੇ ਹੋ ਜੋ ਪ੍ਰਮਾਣਿਕਤਾ ਡੇਟਾਸੈਟ ਦੀਆਂ ਭਵਿੱਖਬਾਣੀਆਂ ਨੂੰ ਵਧੇਰੇ ਸਹੀ ਢੰਗ ਨਾਲ ਪੂਰਾ ਕਰਦਾ ਹੈ।
ਤੁਸੀਂ ਇਸ ਕੰਮ ਲਈ ਕੁਝ ਕਿਸਮ ਦਾ ਫੰਕਸ਼ਨ ਲਿਖ ਸਕਦੇ ਹੋ (ਤਰੀਕੇ ਨਾਲ, ਦੁਬਾਰਾ, ਕਿਸੇ ਕਿਸਮ ਦੇ ਅਨੁਕੂਲਨ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)।

ਤੁਸੀਂ ਆਰ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ caret, ਬਿੰਦੂ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ।

ਨਤੀਜੇ ਵਜੋਂ, ਇਸ ਕੇਸ ਵਿੱਚ, ਗੁਣਾਂ ਦੀ ਮਹੱਤਤਾ ਦੀ ਡਿਗਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ:

ਖੈਰ। ਇਸ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਗਲੋਬਲ ਪ੍ਰਤੀਬਿੰਬ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ:

1. ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇਹਨਾਂ ਟੈਸਟਿੰਗ ਹਾਲਤਾਂ ਦੇ ਤਹਿਤ, ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ, ਪੈਰਾਮੀਟਰ ਸੀ commit_wait
   ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ, ਇਹ ਸਬਡੀਬੀ ਲੌਗ ਬਫਰ ਤੋਂ ਮੌਜੂਦਾ ਲੌਗ ਸਮੂਹ ਵਿੱਚ ਰੀਡੋ ਡੇਟਾ ਲਿਖਣ ਦੇ io ਓਪਰੇਸ਼ਨ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਮੋਡ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ: ਸਮਕਾਲੀ ਜਾਂ ਅਸਿੰਕ੍ਰੋਨਸ।
   ਮੁੱਲ nowait ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ tps ਮੈਟ੍ਰਿਕ ਦੇ ਮੁੱਲ ਵਿੱਚ ਲਗਭਗ ਲੰਬਕਾਰੀ, ਬਹੁਪੱਖੀ ਵਾਧਾ ਹੁੰਦਾ ਹੈ: ਇਹ ਰੀਡੋ ਸਮੂਹਾਂ ਵਿੱਚ ਅਸਿੰਕ੍ਰੋਨਸ io ਮੋਡ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਹੈ।
   ਇੱਕ ਵੱਖਰਾ ਸਵਾਲ ਇਹ ਹੈ ਕਿ ਕੀ ਤੁਹਾਨੂੰ ਇਹ ਭੋਜਨ ਡੇਟਾਬੇਸ ਵਿੱਚ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ ਨਹੀਂ। ਇੱਥੇ ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਸਿਰਫ਼ ਇਹ ਦੱਸਣ ਤੱਕ ਸੀਮਤ ਕਰਦਾ ਹਾਂ: ਇਹ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਾਰਕ ਹੈ।
2. ਇਹ ਲਾਜ਼ੀਕਲ ਹੈ ਕਿ ਸਬਡ: ਦੇ ਲਾਗ ਬਫਰ ਦਾ ਆਕਾਰ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਾਰਕ ਹੈ।
   ਲੌਗ ਬਫਰ ਦਾ ਆਕਾਰ ਜਿੰਨਾ ਛੋਟਾ ਹੁੰਦਾ ਹੈ, ਇਸਦੀ ਬਫਰਿੰਗ ਸਮਰੱਥਾ ਜਿੰਨੀ ਘੱਟ ਹੁੰਦੀ ਹੈ, ਓਨੀ ਹੀ ਜ਼ਿਆਦਾ ਇਹ ਓਵਰਫਲੋ ਹੁੰਦੀ ਹੈ ਅਤੇ/ਜਾਂ ਨਵੇਂ ਰੇਡੌਕਸ ਡੇਟਾ ਦੇ ਇੱਕ ਹਿੱਸੇ ਲਈ ਇਸ ਵਿੱਚ ਇੱਕ ਖਾਲੀ ਖੇਤਰ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਅਸਮਰੱਥਾ ਹੁੰਦੀ ਹੈ।
   ਇਸਦਾ ਮਤਲਬ ਹੈ: ਲੌਗ ਬਫਰ ਵਿੱਚ ਸਪੇਸ ਨਿਰਧਾਰਤ ਕਰਨ ਅਤੇ/ਜਾਂ ਇਸ ਤੋਂ ਰੀਡੋ ਗਰੁੱਪਾਂ ਵਿੱਚ ਰੀਡੋ ਡੇਟਾ ਡੰਪ ਕਰਨ ਨਾਲ ਜੁੜੀ ਦੇਰੀ।
   ਇਹ ਦੇਰੀ, ਬੇਸ਼ੱਕ, ਲੈਣ-ਦੇਣ ਲਈ ਡੇਟਾਬੇਸ ਦੇ ਥ੍ਰੁਪੁੱਟ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
3. ਪੈਰਾਮੀਟਰ db_block_checksum: ਠੀਕ ਹੈ, ਇਹ ਵੀ, ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਸਪੱਸ਼ਟ ਹੈ - ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਪ੍ਰੋਸੈਸਿੰਗ ਸਬ-ਡੇਟਾਬੇਸ ਦੇ ਬਫਰ ਕੈਸ਼ ਵਿੱਚ ਡਾਰਟੀ ਬਲਾਕਾਂ ਦੇ ਗਠਨ ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ.
   ਜੋ, ਜਦੋਂ ਡੇਟਾਬਲਾਕ ਦੇ ਚੈਕਸਮਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਸਮਰੱਥ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਡੇਟਾਬੇਸ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਕਰਨੀ ਪੈਂਦੀ ਹੈ - ਡੇਟਾਬਲਾਕ ਦੇ ਮੁੱਖ ਭਾਗ ਤੋਂ ਇਹਨਾਂ ਚੈੱਕਸਮਾਂ ਦੀ ਗਣਨਾ ਕਰੋ, ਉਹਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ ਕਿ ਡੇਟਾਬਲਾਕ ਸਿਰਲੇਖ ਵਿੱਚ ਕੀ ਲਿਖਿਆ ਹੈ: ਮੇਲ ਖਾਂਦਾ/ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ।
   ਅਜਿਹਾ ਕੰਮ, ਦੁਬਾਰਾ, ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿੱਚ ਦੇਰੀ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਅਤੇ ਇਸਦੇ ਅਨੁਸਾਰ, ਪੈਰਾਮੀਟਰ ਅਤੇ ਵਿਧੀ ਜੋ ਇਸ ਪੈਰਾਮੀਟਰ ਨੂੰ ਸੈੱਟ ਕਰਦੀ ਹੈ ਮਹੱਤਵਪੂਰਨ ਸਾਬਤ ਹੁੰਦੀ ਹੈ।
   ਇਸ ਲਈ ਵਿਕਰੇਤਾ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਇਸ ਪੈਰਾਮੀਟਰ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ, ਇਸਦੇ ਲਈ ਵੱਖ-ਵੱਖ ਮੁੱਲ (ਪੈਰਾਮੀਟਰ) ਅਤੇ ਨੋਟ ਕਰਦਾ ਹੈ ਕਿ ਹਾਂ, ਇੱਕ ਪ੍ਰਭਾਵ ਹੋਵੇਗਾ, ਪਰ, ਨਾਲ ਨਾਲ, ਤੁਸੀਂ "ਬੰਦ" ਤੱਕ, ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਵੱਖ-ਵੱਖ ਪ੍ਰਭਾਵ.

ਖੈਰ, ਇੱਕ ਗਲੋਬਲ ਸਿੱਟਾ.

ਪਹੁੰਚ, ਆਮ ਤੌਰ 'ਤੇ, ਕਾਫ਼ੀ ਕੰਮ ਕਰਨ ਲਈ ਬਾਹਰ ਕਾਮੁਕ.

ਉਹ ਆਪਣੇ ਆਪ ਨੂੰ, ਇੱਕ ਖਾਸ ਸੇਵਾ ਪ੍ਰਣਾਲੀ ਦੇ ਲੋਡ ਟੈਸਟਿੰਗ ਦੇ ਸ਼ੁਰੂਆਤੀ ਪੜਾਵਾਂ ਵਿੱਚ, ਲੋਡ ਲਈ ਇਸਦੀ (ਸਿਸਟਮ) ਅਨੁਕੂਲ ਸੰਰਚਨਾ ਦੀ ਚੋਣ ਕਰਨ ਲਈ, ਲੋਡ ਲਈ ਸਿਸਟਮ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਖੋਜ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।

ਪਰ ਇਹ ਇਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਾਹਰ ਨਹੀਂ ਰੱਖਦਾ - ਘੱਟੋ ਘੱਟ ਸਮਝ ਦੇ ਪੱਧਰ 'ਤੇ: ਸਿਸਟਮ ਨੂੰ "ਅਡਜਸਟਮੈਂਟ ਨੌਬਸ" ਅਤੇ ਇਹਨਾਂ ਗੰਢਾਂ ਦੇ ਰੋਟੇਸ਼ਨ ਦੀਆਂ ਮਨਜ਼ੂਰ ਰੇਂਜਾਂ ਬਾਰੇ ਜਾਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਪਹੁੰਚ ਫਿਰ ਮੁਕਾਬਲਤਨ ਤੇਜ਼ੀ ਨਾਲ ਅਨੁਕੂਲ ਸਿਸਟਮ ਸੰਰਚਨਾ ਨੂੰ ਲੱਭ ਸਕਦੀ ਹੈ।
ਅਤੇ ਟੈਸਟਿੰਗ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਆਧਾਰ 'ਤੇ, ਸਿਸਟਮ ਪ੍ਰਦਰਸ਼ਨ ਮੈਟ੍ਰਿਕਸ ਅਤੇ ਸਿਸਟਮ ਸੈਟਿੰਗਾਂ ਦੇ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਵਿਚਕਾਰ ਸਬੰਧਾਂ ਦੀ ਪ੍ਰਕਿਰਤੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸੰਭਵ ਹੈ.

ਜੋ, ਬੇਸ਼ਕ, ਸਿਸਟਮ ਦੀ ਇਸ ਬਹੁਤ ਡੂੰਘੀ ਸਮਝ ਦੇ ਉਭਾਰ ਵਿੱਚ ਯੋਗਦਾਨ ਪਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਇਸਦੇ ਸੰਚਾਲਨ, ਘੱਟੋ ਘੱਟ ਇੱਕ ਦਿੱਤੇ ਲੋਡ ਦੇ ਅਧੀਨ.

ਅਭਿਆਸ ਵਿੱਚ, ਇਹ ਸਿਸਟਮ ਦੇ ਅਜਿਹੇ ਟੈਸਟਿੰਗ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦੇ ਖਰਚਿਆਂ ਲਈ ਕਸਟਮਾਈਜ਼ਡ ਸਿਸਟਮ ਨੂੰ ਸਮਝਣ ਦੇ ਖਰਚਿਆਂ ਦਾ ਇੱਕ ਵਟਾਂਦਰਾ ਹੈ।

ਮੈਂ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਨੋਟ ਕਰਨਾ ਚਾਹਾਂਗਾ: ਇਸ ਪਹੁੰਚ ਵਿੱਚ, ਵਪਾਰਕ ਸੰਚਾਲਨ ਵਿੱਚ ਹੋਣ ਵਾਲੀਆਂ ਓਪਰੇਟਿੰਗ ਸਥਿਤੀਆਂ ਲਈ ਸਿਸਟਮ ਟੈਸਟਿੰਗ ਦੀ ਯੋਗਤਾ ਦੀ ਡਿਗਰੀ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਤੁਹਾਡੇ ਧਿਆਨ ਅਤੇ ਸਮੇਂ ਲਈ ਧੰਨਵਾਦ।

ਸਰੋਤ: www.habr.com