විද්‍යාත්මක විදින ක්‍රමය, හෝ මිණුම් සලකුණු සහ ප්‍රශස්තිකරණ ඇල්ගොරිතම භාවිතයෙන් දත්ත සමුදා වින්‍යාසයක් තෝරා ගන්නේ කෙසේද

ආයුබෝවන්

මගේ සොයාගැනීම බෙදා ගැනීමට මම තීරණය කළෙමි - සිතුවිලි, අත්හදා බැලීම් සහ දෝෂයේ ඵල.
විශාල වශයෙන්: මෙය සොයා ගැනීමක් නොවේ, ඇත්ත වශයෙන්ම - මේ සියල්ල දිගු කලක් තිස්සේ දැන සිටිය යුතුය, ව්‍යවහාරික සංඛ්‍යාන දත්ත සැකසීමේ සහ ඕනෑම පද්ධතියක ප්‍රශස්තිකරණයේ යෙදී සිටින අයට, විශේෂයෙන් DBMS නොවේ.
සහ: ඔව්, ඔවුන් දන්නවා, ඔවුන් ඔවුන්ගේ පර්යේෂණ පිළිබඳ රසවත් ලිපි ලියනවා, උදාහරණයකි (UPD.: අදහස් දැක්වීමේදී ඔවුන් ඉතා රසවත් ව්‍යාපෘතියක් පෙන්වා දුන්නේය: ottertune )
අනෙක් අතට: තොරතුරු තාක්ෂණ විශේෂඥයින්, DBA අතර අන්තර්ජාලයේ මෙම ප්‍රවේශය පිළිබඳ පුළුල් සඳහනක් හෝ බෙදා හැරීමක් මා දකින්නේ නැත.

ඉතින්, කාරණයට.

අපට කාර්යයක් ඇතැයි උපකල්පනය කරමු: යම් ආකාරයක වැඩකට සේවා සැපයීම සඳහා යම් සේවා පද්ධතියක් සැකසීම.

මෙම කාර්යය ගැන දන්නා කරුණකි: එය කුමක්ද, මෙම කාර්යයේ ගුණාත්මකභාවය මනිනු ලබන්නේ කෙසේද සහ මෙම ගුණාංගය මැනීමේ නිර්ණායකය කුමක්ද.

එය වැඩි වශයෙන් හෝ අඩුවෙන් දන්නා සහ අවබෝධ කර ගෙන ඇති බව උපකල්පනය කරමු: මෙම සේවා පද්ධතිය තුළ (හෝ සමඟ) වැඩ සිදු කරන ආකාරය හරියටම.

“වැඩි හෝ අඩු” - මෙයින් අදහස් කරන්නේ නිෂ්පාදනයේ පවතින දෙයට ප්‍රමාණවත් තරම් පරීක්ෂණ භාරයක් සමඟ සංස්ලේෂණය කර පද්ධතියට යෙදිය හැකි යම් මෙවලමක්, උපයෝගිතා, සේවාවක් සකස් කිරීමට (හෝ එය කොහෙන් හෝ ලබා ගැනීමට) හැකි බවයි. නිෂ්පාදනයේ වැඩ කිරීමට ප්රමාණවත් තරම් ප්රමාණවත් කොන්දේසි යටතේ.

හොඳයි, මෙම සේවා පද්ධතිය සඳහා ගැලපුම් පරාමිතීන් සමූහයක් දන්නා බව උපකල්පනය කරමු, එහි කාර්යයේ ඵලදායිතාව අනුව මෙම පද්ධතිය වින්යාස කිරීමට භාවිතා කළ හැකිය.

සහ ගැටලුව කුමක්ද - මෙම සේවා පද්ධතිය පිළිබඳ ප්‍රමාණවත් සම්පූර්ණ අවබෝධයක් නොමැත, ලබා දී ඇති වේදිකාවක් මත අනාගත පැටවීම සඳහා මෙම පද්ධතියේ සැකසුම් ප්‍රවීණ ලෙස වින්‍යාස කිරීමට සහ පද්ධතියේ අවශ්‍ය ඵලදායිතාව ලබා ගැනීමට ඔබට ඉඩ සලසයි.

හොඳින්. මෙය සෑම විටම පාහේ සිදු වේ.

ඔබට මෙහි කුමක් කළ හැකිද?

හොඳයි, මතකයට එන පළමු දෙය නම් මෙම පද්ධතිය සඳහා ලියකියවිලි දෙස බැලීමයි. ගැලපුම් පරාමිතිවල අගයන් සඳහා පිළිගත හැකි පරාසයන් මොනවාදැයි තේරුම් ගන්න. උදාහරණයක් ලෙස, ඛණ්ඩාංක බැසීමේ ක්‍රමය භාවිතා කරමින්, පරීක්ෂණ වලදී පද්ධති පරාමිතීන් සඳහා අගයන් තෝරන්න.

එම. එහි වින්‍යාස පරාමිතීන් සඳහා නිශ්චිත අගයන් සමූහයක ස්වරූපයෙන් පද්ධතියට යම් ආකාරයක වින්‍යාසයක් ලබා දෙන්න.

මෙම මෙවලම්-උපයෝගිතා, පැටවුම් උත්පාදක යන්ත්රය භාවිතා කරමින්, එය පරීක්ෂණ බරක් යොදන්න.
සහ වටිනාකම දෙස බලන්න - ප්රතිචාරය, හෝ පද්ධතියේ ගුණාත්මක භාවය පිළිබඳ මෙට්රික් එකක්.

දෙවන සිතුවිල්ල මෙය ඉතා දිගු කාලයක් බව නිගමනය විය හැකිය.

හොඳයි, එනම්: සැකසුම් පරාමිතීන් රාශියක් තිබේ නම්, ඒවායේ අගයන් ක්‍රියාත්මක වන පරාසයන් විශාල නම්, එක් එක් බර පරීක්ෂාව සම්පූර්ණ කිරීමට බොහෝ කාලයක් ගතවේ නම්, එසේ නම්: ඔව්, මේ සියල්ල පිළිගත නොහැකි ලෙස ගත විය හැකිය. දිගු කාලය.

හොඳයි, මෙන්න ඔබට තේරුම් ගත හැකි සහ මතක තබා ගත හැකි දේ.

සේවා පද්ධති සැකසුම් පරාමිතිවල අගයන් සමූහයේ සමහර අගයන්හි අනුපිළිවෙලක් ලෙස දෛශිකයක් ඇති බව ඔබට සොයාගත හැකිය.

එවැනි සෑම දෛශිකයක්ම, අනෙකුත් දේවල් සමාන වේ (මෙම දෛශිකය විසින් එය බලපාන්නේ නැත), මෙට්‍රික් හි සම්පූර්ණ නිශ්චිත අගයකට අනුරූප වේ - පරීක්ෂණ භාරයක් යටතේ පද්ධතියේ ක්‍රියාකාරිත්වයේ ගුණාත්මකභාවය පිළිබඳ දර්ශකයකි.

එනම්

අපි පද්ධති වින්‍යාස දෛශිකය මෙසේ දක්වමු කොහෙද ; කොහෙද — පද්ධති වින්‍යාස පරාමිතීන් ගණන, මෙම පරාමිති කීයක් තිබේද යන්න.

සහ මෙයට අනුරූප වන මෙට්රික් අගය එය ලෙස දක්වමු
, එවිට අපට ශ්‍රිතයක් ලැබේ:

හොඳයි, එසේ නම්: සෑම දෙයක්ම වහාම පැමිණෙන්නේ, මගේ නඩුවේදී: මගේ ශිෂ්‍ය කාලයේ සිටම පාහේ අමතක වූ, ශ්‍රිතයක අන්තය සෙවීම සඳහා ඇල්ගොරිතම.

හරි, නමුත් මෙහිදී ආයතනික සහ ව්‍යවහාරික ප්‍රශ්නයක් පැන නගී: කුමන ඇල්ගොරිතම භාවිතා කළ යුතුද.

1. අර්ථයෙන් - ඔබට අතින් අඩුවෙන් කේත කළ හැකි වන පරිදි.
2. සහ එය වැඩ කිරීමට, i.e. අන්තය සොයා ගත්තා (එකක් තිබේ නම්), හොඳයි, අවම වශයෙන් ඛණ්ඩාංක බැසීමට වඩා වේගවත්.

එවැනි ඇල්ගොරිතම දැනටමත් ක්‍රියාවට නංවා ඇති සමහර පරිසරයන් දෙස බැලිය යුතු බව පළමු කරුණ ඉඟි කරයි, සහ යම් ආකාරයකින්, කේතයේ භාවිතයට සූදානම්.
හොඳයි, මම දන්නවා python и cran-r

දෙවන කරුණ නම් ඔබ ඇල්ගොරිතම ගැන, ඒවා මොනවාද, ඒවායේ අවශ්‍යතා මොනවාද සහ ඔවුන්ගේ කාර්යයේ විශේෂාංග ගැන කියවිය යුතු බවයි.

සහ ඔවුන් ලබා දෙන දේ ප්රයෝජනවත් අතුරු ආබාධ විය හැක - ප්රතිඵල, හෝ සෘජුවම ඇල්ගොරිතමයෙන්.

නැතහොත් ඇල්ගොරිතමයේ ප්රතිඵල වලින් ඒවා ලබා ගත හැකිය.

බොහෝ දේ ආදාන කොන්දේසි මත රඳා පවතී.

උදාහරණයක් ලෙස, කිසියම් හේතුවක් නිසා, ඔබට ඉක්මනින් ප්‍රතිඵලයක් ලබා ගැනීමට අවශ්‍ය නම්, හොඳින්, ඔබ ශ්‍රේණිගත ආරෝහණ ඇල්ගොරිතම දෙස බලා ඒවායින් එකක් තෝරා ගත යුතුය.

නැතහොත්, කාලය එතරම් වැදගත් නොවේ නම්, ඔබට උදාහරණයක් ලෙස, ජාන ඇල්ගොරිතමයක් වැනි ස්ටෝචස්ටික් ප්‍රශස්තිකරණ ක්‍රම භාවිතා කළ හැකිය.

මෙම ප්‍රවේශයේ කාර්යය සලකා බැලීමට මම යෝජනා කරමි, පද්ධති වින්‍යාසය තෝරා ගැනීම, ජාන ඇල්ගොරිතමයක් භාවිතා කිරීම, ඊළඟට කතා කිරීමට: රසායනාගාර වැඩ.

මුල්:

1. සේවා පද්ධතියක් ලෙස පවතින්න: oracle xe 18c
2. එය ගනුදෙනු ක්‍රියාකාරකම් සහ ඉලක්කයට සේවය කිරීමට ඉඩ දෙන්න: ගනුදෙනු/තත්පර තුළ උප දත්ත සමුදායේ හැකි ඉහළම ප්‍රතිදානය ලබා ගැනීමට.
3. දත්ත සමඟ වැඩ කිරීමේ ස්වභාවය සහ කාර්යයේ සන්දර්භය තුළ ගනුදෙනු බෙහෙවින් වෙනස් විය හැකිය.
   මේවා විශාල වගු දත්ත ප්‍රමාණයක් සකසන්නේ නැති ගනුදෙනු බව අපි එකඟ වෙමු.
   ඔවුන් නැවත කිරීමට වඩා වැඩි ප්‍රමාණයේ දත්ත උත්පාදනය නොකරන අතර පේළි සහ විශාල වගු විශාල ප්‍රතිශතයක් සකසන්නේ නැත.

මේවා විශාල හෝ අඩු විශාල වගුවක එක් පේළියක් වෙනස් කරන ගනුදෙනු වේ, මෙම වගුවේ කුඩා දර්ශක සංඛ්‍යාවක් ඇත.

මෙම තත්ත්වය තුළ: ගනුදෙනු සැකසීම සඳහා උප දත්ත සමුදායේ ඵලදායිතාව, වෙන් කිරීමක් සමඟ, රෙඩොක්ස් දත්ත ගබඩාව මඟින් සැකසීමේ ගුණාත්මකභාවය තීරණය කරනු ඇත.

වියාචනය - අපි subdb සැකසුම් ගැන විශේෂයෙන් කතා කරන්නේ නම්.

මක්නිසාද යත්, සාමාන්‍ය අවස්ථාවෙහිදී, වගු දත්ත සහ/හෝ වගු ආකෘතිය සමඟ පරිශීලක වැඩ සැලසුම් කිරීම හේතුවෙන්, උදාහරණයක් ලෙස, SQL සැසි අතර ගනුදෙනු අගුලු තිබිය හැක.

ඇත්ත වශයෙන්ම, එය TPS මෙට්‍රික් මත අවපාත බලපෑමක් ඇති කරන අතර මෙය උප දත්ත සමුදායට සාපේක්ෂව බාහිර සාධකයක් වනු ඇත: හොඳයි, වගු ආකෘතිය නිර්මාණය කර ඇති ආකාරය සහ එහි ඇති දත්ත සමඟ වැඩ කිරීමේදී අවහිරතා ඇති වේ.

එබැවින්, අත්හදා බැලීමේ සංශුද්ධතාවය සඳහා, අපි මෙම සාධකය බැහැර කරනු ඇත, සහ පහත මම හරියටම පැහැදිලි කරන්නෙමි.

1. අපි උපකල්පනය කරමු, නිශ්චිතභාවය සඳහා, දත්ත සමුදායට ඉදිරිපත් කරන ලද SQL විධාන වලින් 100% ක්ම DML විධාන වේ.
   උප දත්ත සමුදාය සමඟ ක්‍රියා කරන පරිශීලකයාගේ ලක්ෂණ පරීක්ෂණ වලදී සමාන වීමට ඉඩ දෙන්න.
   එනම්: skl සැසි ගණන, වගු දත්ත, ඒවා සමඟ skl සැසි ක්‍රියා කරන ආකාරය.
2. Subd වැඩ කරන්නේ FORCE LOGGING, ARCHIVELOG mods. ෆ්ලෑෂ්බැක්-දත්ත සමුදා මාදිලිය subd මට්ටමේ දී අක්‍රිය කර ඇත.
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

මුලදී, මෙම පැටවුම් තත්ව යටතේ, මට ගනුදෙනු subd භාවිතා කිරීමට අවශ්‍ය විය SLOB-උපයෝගිතා
එහි අපූරු අංගයක් ඇත, මම කතුවරයා උපුටා දක්වමි:

SLOB හි හදවතෙහි ඇත්තේ "SLOB ක්රමය" ය. SLOB ක්‍රමය වේදිකා පරීක්ෂා කිරීම අරමුණු කරයි
අයදුම්පත් මතභේදයකින් තොරව. කෙනෙකුට උපරිම දෘඩාංග කාර්ය සාධනය ධාවනය කළ නොහැක
යෙදුම් කේතය භාවිතා කිරීම, උදාහරණයක් ලෙස, යෙදුම් අගුලු දැමීම හෝ පවා බැඳී ඇත
Oracle Database blocks බෙදාගැනීම. ඒක හරි - දත්ත බෙදාගැනීමේදී උඩිස් වැඩ ඇත
දත්ත කොටස් තුළ! නමුත් SLOB-එහි පෙරනිමි යෙදවීමේදී-එවැනි මතභේදයකින් තොරය.

මෙම ප්රකාශය: අනුරූප වේ, එයයි.
cl සැසිවල සමාන්තරතාවයේ මට්ටම නියාමනය කිරීම පහසුය, මෙය යතුරයි -t උපයෝගීතාව දියත් කරන්න runit.sh SLOB වෙතින්
DML විධානවල ප්‍රතිශතය නියාමනය කරනු ලබන්නේ, subd වෙත යවන කෙටි පණිවිඩ ගණන, එක් එක් පෙළ සැසිය, පරාමිතිය UPDATE_PCT
වෙනම සහ ඉතා පහසු ලෙස: SLOB එයම, පැටවීමේ සැසියට පෙර සහ පසු - statspack හෝ awr-snapshots (සකස් කිරීමට සකසා ඇති දේ) සූදානම් කරයි.

කෙසේ වෙතත්, එය එසේ විය 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 කින් වින්යාස කළෙමි.

පැටවීම යටතේ ඇති subd හි ක්‍රියාකාරිත්වය විස්තර කරන statspack වාර්තාවක කෑල්ලක්

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;

Oracle දත්ත සමුදායන් පවත්වාගෙන යාමේ පළපුරුද්දක් ඇති පුද්ගලයෙකුට නිශ්චිතව දක්වා ඇති දත්ත සමඟ වැඩ කිරීම සඳහා දත්ත සමුදායේ වැඩි ඵලදායිතාවයක් ලබා ගැනීම සඳහා නිශ්චිත පරාමිති සහ ඒවායේ පිළිගත හැකි අගයන්ගෙන් කුමන අගයන් සැකසිය යුතුද යන්න නිසැකවම පැවසිය හැකිය. යෙදුම් කේතය, මෙහි ඉහත.

ඒත්.

රසායනාගාර කාර්යයේ කාරණය වන්නේ ප්‍රශස්තිකරණ ඇල්ගොරිතම විසින්ම මෙය අපට සාපේක්ෂව ඉක්මනින් පැහැදිලි කරන බව පෙන්වීමයි.

අපට, ඉතිරිව ඇත්තේ, වෙනස් කළ යුතු පරාමිති මොනවාද සහ කුමන පරාසයකදැයි සොයා ගැනීමට, අභිරුචිකරණය කළ හැකි පද්ධතිය හරහා ලේඛනය දෙස බැලීම පමණි.
තවද: තෝරාගත් ප්‍රශස්තකරණ ඇල්ගොරිතමයේ අභිරුචි පද්ධතිය සමඟ වැඩ කිරීමට භාවිතා කරන කේතය කේත කරන්න.

ඉතින්, දැන් කේතය ගැන.
ගැන මම ඉහත කතා කළා cran-r, i.e.: අභිරුචිකරණය කළ පද්ධතිය සමඟ ඇති සියලුම උපාමාරු R script ආකාරයෙන් සංවිධානය කර ඇත.

සත්‍ය කාර්යය, විශ්ලේෂණය, මෙට්‍රික් අගය අනුව තේරීම, පද්ධති තත්ත්ව දෛශික: මෙය පැකේජයකි GA (ප්‍රලේඛනය)
පැකේජය, මෙම අවස්ථාවෙහිදී, ඉතා සුදුසු නොවේ, එය දෛශික (වර්ණදේහ, පැකේජය අනුව නම්) භාගික කොටසක් සහිත සංඛ්‍යා නූල් ආකාරයෙන් නියම කිරීමට අපේක්ෂා කරන අර්ථයෙන්.

සහ මගේ දෛශිකය, සැකසුම් පරාමිතිවල අගයන්ගෙන්: මේවා ප්‍රමාණ 14කි - පූර්ණ සංඛ්‍යා සහ නූල් අගයන්.

තන්තු අගයන් සඳහා නිශ්චිත සංඛ්‍යා කිහිපයක් ලබා දීමෙන් ගැටළුව, ඇත්ත වශයෙන්ම, පහසුවෙන් මග හැරිය හැක.

මේ අනුව, අවසානයේදී, R script හි ප්‍රධාන කොටස මෙසේ දිස්වේ:

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 subroutine ගුණාංග ga අත්‍යවශ්‍යයෙන්ම, සෙවුම් අවකාශයේ ප්‍රදේශයක් නියම කර ඇති අතර, යෝග්‍යතා ශ්‍රිතයේ උපරිම අගය ලබා ගන්නා එවැනි දෛශිකයක් (හෝ දෛශික) සඳහා සෙවීමක් සිදු කරනු ලැබේ.

ga subroutine යෝග්‍යතා කාර්යය උපරිම කරමින් සෙවීමක් සිදු කරයි.

හොඳයි, එසේ නම්, මෙම අවස්ථාවේ දී, යෝග්‍යතා ශ්‍රිතය, දෛශිකය subd හි ඇතැම් පරාමිතීන් සඳහා අගයන් සමූහයක් ලෙස අවබෝධ කර ගැනීම, subd වෙතින් මෙට්‍රික් එකක් ලබා ගැනීම අවශ්‍ය බව පෙනේ.

එනම්: ලබා දී ඇති subd සැකසුමකින් සහ subd මත ලබා දී ඇති භාරයක් සමඟ කොපමණ ප්‍රමාණයක්: subd තත්පරයකට ගනුදෙනු සකසයි.

එනම්, දිග හැරෙන විට, යෝග්‍යතා ශ්‍රිතය තුළ පහත බහු-පියවර සිදු කළ යුතුය:

1. සංඛ්‍යා ආදාන දෛශිකය සැකසීම - එය උප දත්ත පරාමිතීන් සඳහා අගයන් බවට පරිවර්තනය කිරීම.
2. දී ඇති ප්‍රමාණයේ දී ඇති නැවත කරන්න කණ්ඩායම් සංඛ්‍යාවක් නිර්මාණය කිරීමට උත්සාහ කිරීම. එපමණක් නොව, උත්සාහය අසාර්ථක විය හැකිය.
   අත්හදා බැලීමේ සංශුද්ධතාවය සඳහා යම් ප්‍රමාණයකින් සහ යම් ප්‍රමාණයකින් දැනටමත් subd හි පැවති සඟරා කණ්ඩායම් - d.b. මකා දමන ලදී.
3. පෙර කරුණ සාර්ථක නම්: දත්ත සමුදායට වින්‍යාස පරාමිතීන්ගේ අගයන් සඳහන් කිරීම (නැවත: අසාර්ථක වීමක් විය හැක)
4. පෙර පියවර සාර්ථක නම්: අලුතින් දක්වා ඇති පරාමිති අගයන් ක්රියාත්මක වන පරිදි subd නතර කිරීම, subd ආරම්භ කිරීම. (නැවත: දෝෂයක් තිබිය හැක)
5. පෙර පියවර සාර්ථක නම්: පැටවීමේ පරීක්ෂණයක් කරන්න. subd එකෙන් metrics ගන්න.
6. subd එක එහි මුල් තත්වයට ගෙන එන්න, i.e. අමතර ලොග් කණ්ඩායම් මකා දමන්න, මුල් උප දත්ත සමුදා වින්‍යාසය ක්‍රියා කිරීමට ආපසු යන්න.

යෝග්‍යතා ක්‍රියාකාරී කේතය

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)
}

එම. සියලුම වැඩ: යෝග්‍යතා ක්‍රියාකාරිත්වය තුළ සිදු කෙරේ.

ga-subroutine දෛශික හෝ, වඩාත් නිවැරදිව, වර්ණදේහ සකසයි.
එහිදී, අපට වඩාත් වැදගත් වන්නේ යෝග්‍යතා ශ්‍රිතය විශාල අගයන් නිපදවන ජාන සහිත වර්ණදේහ තෝරාගැනීමයි.

මෙය සාරය වශයෙන්, N-මාන සෙවුම් අවකාශයක දෛශිකයක් භාවිතා කරමින් ප්‍රශස්ත වර්ණදේහ කට්ටලයක් සෙවීමේ ක්‍රියාවලියයි.

ඉතා පැහැදිලි, සවිස්තරාත්මක පැහැදිලි කිරීම, R-කේතයේ උදාහරණ සමඟ, ජාන ඇල්ගොරිතමයේ කාර්යය.

මම තාක්ෂණික කරුණු දෙකක් වෙන වෙනම සටහන් කිරීමට කැමැත්තෙමි.

කාර්යයෙන් සහායක ඇමතුම් evaluate, උදාහරණයක් ලෙස, නැවතුම්-ආරම්භය, subd පරාමිතියෙහි අගය සැකසීම, මත පදනම්ව සිදු කරනු ලැබේ cran-r කාර්යයන් system2

එහි ආධාරයෙන්: සමහර bash script හෝ command කැඳවනු ලැබේ.

උදාහරණ වශයෙන්:

set_db_parameter

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 දහසක් tps: වෙනම ප්රශ්නයක්.
රසායනාගාර කාර්යයේ රාමුව තුළ, මෙම රූපය වැදගත් නොවේ, වැදගත් වන්නේ ගතිකත්වය, මෙම අගය වෙනස් වන ආකාරයයි.

මෙහි ගතිකත්වය හොඳයි.
වර්ණදේහ දෛශික හරහා වර්ග කිරීම: ආවරණය කරන ලද මෙට්‍රික් අගය, ga-ඇල්ගොරිතමයට අවම වශයෙන් එක් සාධකයක් සැලකිය යුතු ලෙස බලපාන බව පැහැදිලිය.
වක්‍ර අගයන්හි තරමක් ප්‍රබල ගතිකත්වය අනුව විනිශ්චය කිරීම, සැලකිය යුතු තරම් කුඩා වුවද බලපෑමක් ඇති කරන අවම වශයෙන් තවත් එක් සාධකයක් තිබේ.

ඔබට අවශ්‍ය ස්ථානය මෙයයි attribute-importance කුමන ගුණාංග (හොඳයි, මෙම අවස්ථාවේ දී, සුසර කිරීමේ දෛශිකයේ සංරචක) සහ ඒවා මෙට්‍රික් අගයට බලපාන්නේ කෙසේද යන්න තේරුම් ගැනීමට විශ්ලේෂණය.
සහ මෙම තොරතුරු වලින්: සැලකිය යුතු ගුණාංගවල වෙනස්කම් වලට බලපාන සාධක මොනවාදැයි තේරුම් ගන්න.

ධාවනය attribute-importance විවිධ ආකාරවලින් හැකි.

මෙම අරමුණු සඳහා, මම ඇල්ගොරිතමයට කැමතියි randomForest එකම නමින් R පැකේජය (ප්‍රලේඛනය)
randomForest, මම පොදුවේ ඔහුගේ කාර්යය සහ විශේෂයෙන්ම ගුණාංගවල වැදගත්කම තක්සේරු කිරීම සඳහා ඔහුගේ ප්රවේශය තේරුම් ගෙන ඇති පරිදි, ගුණාංග මත ප්රතිචාර විචල්යයේ යැපීම පිළිබඳ යම් ආකෘතියක් ගොඩනඟයි.

අපගේ නඩුවේදී, ප්‍රතිචාර විචල්‍යය යනු භාර පරීක්ෂණ වලදී දත්ත සමුදායෙන් ලබාගත් මෙට්‍රික් එකකි: tps;
සහ ගුණාංග යනු සුසර කිරීමේ දෛශිකයේ සංරචක වේ.

ඉතින් මෙතන randomForest එක් එක් ආදර්ශ ගුණාංගයේ වැදගත්කම අංක දෙකකින් ඇගයීමට ලක් කරයි: %IncMSE — ආකෘතියක මෙම ගුණාංගය පැවතීම/නොපැවතීම මෙම ආකෘතියේ MSE ගුණාත්මක භාවය වෙනස් කරන ආකාරය (මධ්‍යන්‍ය වර්ග දෝෂය);

IncNodePurity යනු මෙම ගුණාංගයේ අගයන් මත පදනම්ව, නිරීක්ෂණ සහිත දත්ත කට්ටලයක් බෙදිය හැකි ආකාරය පිළිබිඹු කරන සංඛ්‍යාවකි, එවිට එක් කොටසක මෙට්‍රික් එක අගයක් සහිත දත්ත ඇති අතර අනෙක් කොටසේ විස්තර කෙරේ. මෙට්රික් වල තවත් අගයක්.
හොඳයි, එනම්: මෙය කොතරම් දුරට වර්ගීකරණ ගුණාංගයක්ද (මම RandomForest හි වඩාත් පැහැදිලි, රුසියානු භාෂා පැහැදිලි කිරීම දුටුවෙමි මෙහි).

පැටවීමේ පරීක්ෂණවල ප්‍රතිඵල සහිත දත්ත කට්ටලයක් සැකසීම සඳහා කම්කරු-ගොවි R-කේතය:

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

ඔබට ඔබේ අත්වලින් ඇල්ගොරිතමයේ අධිපරිමාණ සෘජුවම තෝරා ගත හැකි අතර, ආකෘතියේ ගුණාත්මකභාවය කෙරෙහි අවධානය යොමු කරමින්, වලංගු දත්ත කට්ටලයේ අනාවැකි වඩාත් නිවැරදිව ඉටු කරන ආකෘතියක් තෝරන්න.
ඔබට මෙම කාර්යය සඳහා යම් ආකාරයක කාර්යයක් ලිවිය හැකිය (මාර්ගය විසින්, නැවතත්, යම් ආකාරයක ප්රශස්තිකරණ ඇල්ගොරිතමයක් භාවිතා කිරීම).

ඔබට R පැකේජය භාවිතා කළ හැකිය caret, කාරණය නොවේ වැදගත්.

ප්රතිඵලයක් වශයෙන්, මෙම අවස්ථාවෙහිදී, ගුණාංගවල වැදගත්කම තක්සේරු කිරීම සඳහා පහත ප්රතිඵලය ලබා ගනී:

හොඳින්. මේ අනුව, අපට ගෝලීය පරාවර්තනය ආරම්භ කළ හැකිය:

1. මෙම පරීක්ෂණ තත්වයන් යටතේ වඩාත්ම වැදගත් වන්නේ පරාමිතිය බව පෙනේ commit_wait
   තාක්ෂණික වශයෙන්, එය subdb ලොග් බෆරයේ සිට වර්තමාන ලොග් කණ්ඩායමට දත්ත නැවත ලිවීමේ io මෙහෙයුමේ ක්‍රියාත්මක කිරීමේ මාදිලිය නියම කරයි: සමමුහුර්ත හෝ අසමමිතික.
   අගය nowait එහි ප්‍රතිඵලයක් ලෙස tps මෙට්‍රික් අගයෙහි සිරස් අතට බහුවිධ වැඩි වීමක් සිදුවේ: මෙය නැවත කරන්න කණ්ඩායම් තුළ අසමමුහුර්ත io මාදිලිය ඇතුළත් කිරීමයි.
   වෙනම ප්‍රශ්නයක් නම් ඔබ මෙය ආහාර දත්ත ගබඩාවක කළ යුතුද නැද්ද යන්නයි. මෙහිදී මම ප්‍රකාශ කිරීමට පමණක් සීමා කරමි: මෙය සැලකිය යුතු සාධකයකි.
2. subd හි ලොග් බෆරයේ ප්‍රමාණය සැලකිය යුතු සාධකයක් වීම තර්කානුකූලයි.
   ලොග් බෆරයේ ප්‍රමාණය කුඩා වන තරමට එහි බෆරින් ධාරිතාව අඩු වන තරමට එය පිටාර ගැලීම සහ/හෝ නව රෙඩොක්ස් දත්ත කොටසක් සඳහා එහි නිදහස් ප්‍රදේශයක් වෙන් කිරීමට නොහැකි වීම.
   මෙයින් අදහස් කරන්නේ: ලොග් බෆරයේ ඉඩ වෙන් කිරීම සහ/හෝ එයින් නැවත කරන්න දත්ත නැවත සකස් කිරීමේ කණ්ඩායම්වලට බැහැර කිරීම හා සම්බන්ධ ප්‍රමාදයන්.
   මෙම ප්‍රමාදයන්, ඇත්ත වශයෙන්ම, ගනුදෙනු සඳහා දත්ත සමුදායේ ප්‍රතිදානය කෙරෙහි බලපෑ යුතුය.
3. පරාමිතිය db_block_checksum: හොඳයි, එසේම, පොදුවේ එය පැහැදිලිය - ගණුදෙණු සැකසීම උප දත්ත සමුදායේ බෆර් හැඹිලියේ ඩාටි බ්ලොක් සෑදීමට හේතු වේ.
   කුමන, දත්ත වාරණ වල චෙක්සම් පරීක්ෂා කිරීම සක්‍රීය කර ඇති විට, දත්ත සමුදාය සැකසීමට සිදු වේ - මෙම චෙක්සම් දත්ත වාරණයේ ශරීරයෙන් ගණනය කරන්න, දත්ත වාරණ ශීර්ෂයේ ලියා ඇති දේ සමඟ ඒවා පරීක්ෂා කරන්න: ගැලපීම් / නොගැලපේ.
   එවැනි වැඩ, නැවතත්, දත්ත සැකසීම ප්රමාද කළ නොහැකි අතර, ඒ අනුව, මෙම පරාමිතිය සකසන පරාමිතිය සහ යාන්ත්රණය සැලකිය යුතු වේ.
   වෙළෙන්දා මෙම පරාමිතිය සඳහා ලියකියවිලි තුළ, ඒ සඳහා විවිධ අගයන් (පරාමිතිය) ලබා දෙන අතර, ඔව්, බලපෑමක් ඇති බව සටහන් කරයි, නමුත්, හොඳයි, ඔබට විවිධ අගයන් තෝරා ගත හැකිය, "අක්‍රිය" සහ විවිධ බලපෑම්.

හොඳයි, ගෝලීය නිගමනයක්.

ප්රවේශය, සාමාන්යයෙන්, තරමක් වැඩ කරන බවට හැරෙනවා.

යම් සේවා පද්ධතියක බර පරීක්ෂා කිරීමේ මුල් අවධියේදී, බර පැටවීම සඳහා එහි (පද්ධතිය) ප්‍රශස්ත වින්‍යාසය තෝරා ගැනීම සඳහා, බර පැටවීම සඳහා පද්ධතිය සැකසීමේ විශේෂතා ගැන ඕනෑවට වඩා සොයා බැලීමට ඔහු ඉඩ දෙයි.

නමුත් එය සම්පූර්ණයෙන්ම බැහැර නොකරයි - අවම වශයෙන් අවබෝධතා මට්ටමින්: පද්ධතිය “ගැලපුම් බොත්තම්” සහ මෙම බොත්තම් වල භ්‍රමණ අවසර පරාසයන් පිළිබඳව දැන සිටිය යුතුය.

එවිට ප්‍රවේශයට සාපේක්ෂව ඉක්මනින් ප්‍රශස්ත පද්ධති වින්‍යාසය සොයා ගත හැක.
සහ පරීක්ෂණ ප්රතිඵල මත පදනම්ව, පද්ධතියේ කාර්ය සාධන ප්රමිතික සහ පද්ධති සැකසුම් පරාමිතීන්ගේ අගයන් අතර සම්බන්ධතාවයේ ස්වභාවය පිළිබඳ තොරතුරු ලබා ගත හැකිය.

ඇත්ත වශයෙන්ම, පද්ධතිය, එහි ක්‍රියාකාරිත්වය, අවම වශයෙන් දී ඇති බරක් යටතේ මෙම ඉතා ගැඹුරු අවබෝධය මතුවීමට දායක විය යුතුය.

ප්රායෝගිකව, මෙය පද්ධතියේ එවැනි පරීක්ෂණ සකස් කිරීමේ පිරිවැය සඳහා අභිරුචි කළ පද්ධතිය අවබෝධ කර ගැනීමේ පිරිවැය හුවමාරු කිරීමකි.

මම වෙන වෙනම සටහන් කිරීමට කැමැත්තෙමි: මෙම ප්‍රවේශයේදී, වාණිජ ක්‍රියාකාරිත්වයේ දී එය සතුව ඇති මෙහෙයුම් කොන්දේසි සඳහා පද්ධති පරීක්ෂාවේ ප්‍රමාණවත් භාවයේ මට්ටම විවේචනාත්මකව වැදගත් වේ.

ඔබගේ අවධානයට සහ කාලයට ස්තූතියි.

මූලාශ්රය: www.habr.com