misao全文検索

＞　 2001/10/11 (木) 16:42:34　 ◆　 ▼　 ◇　 [mirai]

> > あぁ
> > PSDKみたら確かに書いてあった
> > 優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな
> > というか適当に書いてた俺は無駄骨ですか
> > 時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
> > というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君
> > #include <stdio.h>
> > #include <windows.h>
> > int LogMessage(LPCTSTR message)
> > {
> >   static HANDLE log_file = NULL;
> >   static SYSTEMTIME previous_time;
> >   BOOL reopen_log = FALSE;
> >   DWORD bytes_written;
> >   if(!log_file) {
> >     GetLocalTime(&previous_time);
> >     reopen_log = TRUE;
> >   } else {
> >     SYSTEMTIME current_time;
> >     GetLocalTime(&current_time);
> >     if(previous_time.wYear != current_time.wYear ||
> >        previous_time.wMonth != current_time.wMonth ||
> >        previous_time.wDay != current_time.wDay ||
> >        previous_time.wHour != current_time.wHour ||
> >        previous_time.wMinute != current_time.wMinute) {
> >       reopen_log = TRUE;
> >       previous_time = current_time;
> >     }
> >   }
> >   if(reopen_log) {
> >     TCHAR filename[MAX_PATH];
> >     DWORD file_pointer;
> >     wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
> >       previous_time.wYear,
> >       previous_time.wMonth + 1,
> >       previous_time.wDay,
> >       previous_time.wHour,
> >       previous_time.wMinute
> >       );
> >     if(log_file) {
> >       CloseHandle(log_file);
> >     }
> >     log_file = CreateFile(filename, GENERIC_WRITE,
> >       FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
> >     if(!log_file) {
> >       return -1;
> >     }
> >     file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
> >     if(file_pointer == INVALID_SET_FILE_POINTER) {
> >       return -1;
> >     }
> >   }
> >   if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
> >     return -1;
> >   }
> >   return bytes_written;
> > }
> > int main(void) {
> >   int i;
> >   for(i = 0; i < 10; i++) {
> >     char buf[100];
> >     wsprintf(buf, "Log %02d\r\n", i);
> >     printf("%s", buf);
> >     LogMessage(buf);
> >     Sleep(10000);
> >   }
> >   return 0;
> > }
> ｺﾋﾟﾍﾟうぜぇ
> > ｺﾋﾟﾍﾟうぜぇ
> 全文引用すんなﾀｺ

お前も全文引用してるだろうがﾁﾝｶｽ

参考：2001/10/11(木)16時41分55秒

＞　 2001/10/11 (木) 16:41:55　 ◆　 ▼　 ◇　 [mirai]

> > あぁ
> > PSDKみたら確かに書いてあった
> > 優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな
> > というか適当に書いてた俺は無駄骨ですか
> > 時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
> > というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君
> > #include <stdio.h>
> > #include <windows.h>
> > int LogMessage(LPCTSTR message)
> > {
> >   static HANDLE log_file = NULL;
> >   static SYSTEMTIME previous_time;
> >   BOOL reopen_log = FALSE;
> >   DWORD bytes_written;
> >   if(!log_file) {
> >     GetLocalTime(&previous_time);
> >     reopen_log = TRUE;
> >   } else {
> >     SYSTEMTIME current_time;
> >     GetLocalTime(&current_time);
> >     if(previous_time.wYear != current_time.wYear ||
> >        previous_time.wMonth != current_time.wMonth ||
> >        previous_time.wDay != current_time.wDay ||
> >        previous_time.wHour != current_time.wHour ||
> >        previous_time.wMinute != current_time.wMinute) {
> >       reopen_log = TRUE;
> >       previous_time = current_time;
> >     }
> >   }
> >   if(reopen_log) {
> >     TCHAR filename[MAX_PATH];
> >     DWORD file_pointer;
> >     wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
> >       previous_time.wYear,
> >       previous_time.wMonth + 1,
> >       previous_time.wDay,
> >       previous_time.wHour,
> >       previous_time.wMinute
> >       );
> >     if(log_file) {
> >       CloseHandle(log_file);
> >     }
> >     log_file = CreateFile(filename, GENERIC_WRITE,
> >       FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
> >     if(!log_file) {
> >       return -1;
> >     }
> >     file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
> >     if(file_pointer == INVALID_SET_FILE_POINTER) {
> >       return -1;
> >     }
> >   }
> >   if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
> >     return -1;
> >   }
> >   return bytes_written;
> > }
> > int main(void) {
> >   int i;
> >   for(i = 0; i < 10; i++) {
> >     char buf[100];
> >     wsprintf(buf, "Log %02d\r\n", i);
> >     printf("%s", buf);
> >     LogMessage(buf);
> >     Sleep(10000);
> >   }
> >   return 0;
> > }
> ｺﾋﾟﾍﾟうぜぇ

全文引用すんなﾀｺ

参考：2001/10/11(木)16時40分28秒

＞　 2001/10/11 (木) 16:41:12　 ◆　 ▼　 ◇　 [mirai]

> > あぁ
> > PSDKみたら確かに書いてあった
> > 優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな
> > というか適当に書いてた俺は無駄骨ですか
> > 時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
> > というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君
> > #include <stdio.h>
> > #include <windows.h>
> > int LogMessage(LPCTSTR message)
> > {
> >   static HANDLE log_file = NULL;
> >   static SYSTEMTIME previous_time;
> >   BOOL reopen_log = FALSE;
> >   DWORD bytes_written;
> >   if(!log_file) {
> >     GetLocalTime(&previous_time);
> >     reopen_log = TRUE;
> >   } else {
> >     SYSTEMTIME current_time;
> >     GetLocalTime(&current_time);
> >     if(previous_time.wYear != current_time.wYear ||
> >        previous_time.wMonth != current_time.wMonth ||
> >        previous_time.wDay != current_time.wDay ||
> >        previous_time.wHour != current_time.wHour ||
> >        previous_time.wMinute != current_time.wMinute) {
> >       reopen_log = TRUE;
> >       previous_time = current_time;
> >     }
> >   }
> >   if(reopen_log) {
> >     TCHAR filename[MAX_PATH];
> >     DWORD file_pointer;
> >     wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
> >       previous_time.wYear,
> >       previous_time.wMonth + 1,
> >       previous_time.wDay,
> >       previous_time.wHour,
> >       previous_time.wMinute
> >       );
> >     if(log_file) {
> >       CloseHandle(log_file);
> >     }
> >     log_file = CreateFile(filename, GENERIC_WRITE,
> >       FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
> >     if(!log_file) {
> >       return -1;
> >     }
> >     file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
> >     if(file_pointer == INVALID_SET_FILE_POINTER) {
> >       return -1;
> >     }
> >   }
> >   if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
> >     return -1;
> >   }
> >   return bytes_written;
> > }
> > int main(void) {
> >   int i;
> >   for(i = 0; i < 10; i++) {
> >     char buf[100];
> >     wsprintf(buf, "Log %02d\r\n", i);
> >     printf("%s", buf);
> >     LogMessage(buf);
> >     Sleep(10000);
> >   }
> >   return 0;
> > }
> ｺﾋﾟﾍﾟうぜぇ

全文引用うぜぇ死ね

参考：2001/10/11(木)16時40分28秒

＞　 2001/10/11 (木) 16:40:46　 ◆　 ▼　 ◇　 [mirai]

> > あぁ
> > PSDKみたら確かに書いてあった
> > 優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな
> > というか適当に書いてた俺は無駄骨ですか
> > 時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
> > というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君
> > #include <stdio.h>
> > #include <windows.h>
> > int LogMessage(LPCTSTR message)
> > {
> >   static HANDLE log_file = NULL;
> >   static SYSTEMTIME previous_time;
> >   BOOL reopen_log = FALSE;
> >   DWORD bytes_written;
> >   if(!log_file) {
> >     GetLocalTime(&previous_time);
> >     reopen_log = TRUE;
> >   } else {
> >     SYSTEMTIME current_time;
> >     GetLocalTime(&current_time);
> >     if(previous_time.wYear != current_time.wYear ||
> >        previous_time.wMonth != current_time.wMonth ||
> >        previous_time.wDay != current_time.wDay ||
> >        previous_time.wHour != current_time.wHour ||
> >        previous_time.wMinute != current_time.wMinute) {
> >       reopen_log = TRUE;
> >       previous_time = current_time;
> >     }
> >   }
> >   if(reopen_log) {
> >     TCHAR filename[MAX_PATH];
> >     DWORD file_pointer;
> >     wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
> >       previous_time.wYear,
> >       previous_time.wMonth + 1,
> >       previous_time.wDay,
> >       previous_time.wHour,
> >       previous_time.wMinute
> >       );
> >     if(log_file) {
> >       CloseHandle(log_file);
> >     }
> >     log_file = CreateFile(filename, GENERIC_WRITE,
> >       FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
> >     if(!log_file) {
> >       return -1;
> >     }
> >     file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
> >     if(file_pointer == INVALID_SET_FILE_POINTER) {
> >       return -1;
> >     }
> >   }
> >   if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
> >     return -1;
> >   }
> >   return bytes_written;
> > }
> > int main(void) {
> >   int i;
> >   for(i = 0; i < 10; i++) {
> >     char buf[100];
> >     wsprintf(buf, "Log %02d\r\n", i);
> >     printf("%s", buf);
> >     LogMessage(buf);
> >     Sleep(10000);
> >   }
> >   return 0;
> > }
> プログラム
> うぜえ

全文引用うぜぇ

参考：2001/10/11(木)16時39分47秒

＞　 2001/10/11 (木) 16:40:28　 ◆　 ▼　 ◇　 [mirai]

> > 「必要があれば」を毎回算出するｺｽﾄと天秤にかけるよ
> > つか、ﾛｸﾞﾌｧｲﾙとﾛｸﾞ内容の時間が多少ずれてもかまわんよ
> > との許しがでたのでもう解決した(´ー｀)ゞ
> > 優先度と処理の配分に関しては、SetThreadPriorityのところに、
> > 「同じ優先順位レベルに複数のスレッドが存在する場合、
> > それらのスレッドはラウンドロビン形式でスケジューリングされ、
> > より高いレベルの実行可能なスレッドが存在しない場合に限って、
> > より低いレベルのスレッドが実行されます。」
> > ってあるので、低いのは実行されないと思うんだけどちゃうのかな？(;´Д`)
> あぁ
> PSDKみたら確かに書いてあった
> 優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな
> というか適当に書いてた俺は無駄骨ですか
> 時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
> というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君
> #include <stdio.h>
> #include <windows.h>
> int LogMessage(LPCTSTR message)
> {
>   static HANDLE log_file = NULL;
>   static SYSTEMTIME previous_time;
>   BOOL reopen_log = FALSE;
>   DWORD bytes_written;
>   if(!log_file) {
>     GetLocalTime(&previous_time);
>     reopen_log = TRUE;
>   } else {
>     SYSTEMTIME current_time;
>     GetLocalTime(&current_time);
>     if(previous_time.wYear != current_time.wYear ||
>        previous_time.wMonth != current_time.wMonth ||
>        previous_time.wDay != current_time.wDay ||
>        previous_time.wHour != current_time.wHour ||
>        previous_time.wMinute != current_time.wMinute) {
>       reopen_log = TRUE;
>       previous_time = current_time;
>     }
>   }
>   if(reopen_log) {
>     TCHAR filename[MAX_PATH];
>     DWORD file_pointer;
>     wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
>       previous_time.wYear,
>       previous_time.wMonth + 1,
>       previous_time.wDay,
>       previous_time.wHour,
>       previous_time.wMinute
>       );
>     if(log_file) {
>       CloseHandle(log_file);
>     }
>     log_file = CreateFile(filename, GENERIC_WRITE,
>       FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
>     if(!log_file) {
>       return -1;
>     }
>     file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
>     if(file_pointer == INVALID_SET_FILE_POINTER) {
>       return -1;
>     }
>   }
>   if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
>     return -1;
>   }
>   return bytes_written;
> }
> int main(void) {
>   int i;
>   for(i = 0; i < 10; i++) {
>     char buf[100];
>     wsprintf(buf, "Log %02d\r\n", i);
>     printf("%s", buf);
>     LogMessage(buf);
>     Sleep(10000);
>   }
>   return 0;
> }

ｺﾋﾟﾍﾟうぜぇ

参考：2001/10/11(木)16時38分09秒

＞　 2001/10/11 (木) 16:39:47　 ◆　 ▼　 ◇　 [mirai]

> > 「必要があれば」を毎回算出するｺｽﾄと天秤にかけるよ
> > つか、ﾛｸﾞﾌｧｲﾙとﾛｸﾞ内容の時間が多少ずれてもかまわんよ
> > との許しがでたのでもう解決した(´ー｀)ゞ
> > 優先度と処理の配分に関しては、SetThreadPriorityのところに、
> > 「同じ優先順位レベルに複数のスレッドが存在する場合、
> > それらのスレッドはラウンドロビン形式でスケジューリングされ、
> > より高いレベルの実行可能なスレッドが存在しない場合に限って、
> > より低いレベルのスレッドが実行されます。」
> > ってあるので、低いのは実行されないと思うんだけどちゃうのかな？(;´Д`)
> あぁ
> PSDKみたら確かに書いてあった
> 優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな
> というか適当に書いてた俺は無駄骨ですか
> 時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
> というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君
> #include <stdio.h>
> #include <windows.h>
> int LogMessage(LPCTSTR message)
> {
>   static HANDLE log_file = NULL;
>   static SYSTEMTIME previous_time;
>   BOOL reopen_log = FALSE;
>   DWORD bytes_written;
>   if(!log_file) {
>     GetLocalTime(&previous_time);
>     reopen_log = TRUE;
>   } else {
>     SYSTEMTIME current_time;
>     GetLocalTime(&current_time);
>     if(previous_time.wYear != current_time.wYear ||
>        previous_time.wMonth != current_time.wMonth ||
>        previous_time.wDay != current_time.wDay ||
>        previous_time.wHour != current_time.wHour ||
>        previous_time.wMinute != current_time.wMinute) {
>       reopen_log = TRUE;
>       previous_time = current_time;
>     }
>   }
>   if(reopen_log) {
>     TCHAR filename[MAX_PATH];
>     DWORD file_pointer;
>     wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
>       previous_time.wYear,
>       previous_time.wMonth + 1,
>       previous_time.wDay,
>       previous_time.wHour,
>       previous_time.wMinute
>       );
>     if(log_file) {
>       CloseHandle(log_file);
>     }
>     log_file = CreateFile(filename, GENERIC_WRITE,
>       FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
>     if(!log_file) {
>       return -1;
>     }
>     file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
>     if(file_pointer == INVALID_SET_FILE_POINTER) {
>       return -1;
>     }
>   }
>   if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
>     return -1;
>   }
>   return bytes_written;
> }
> int main(void) {
>   int i;
>   for(i = 0; i < 10; i++) {
>     char buf[100];
>     wsprintf(buf, "Log %02d\r\n", i);
>     printf("%s", buf);
>     LogMessage(buf);
>     Sleep(10000);
>   }
>   return 0;
> }

プログラム
うぜえ

参考：2001/10/11(木)16時38分09秒

＞　 2001/10/11 (木) 16:38:09　 ◆　 ▼　 ◇　 [mirai]

> > お前は根本的に間違っている
> > ファイルは開いたままにしておいてログを書きこむときに
> > 現在時刻を取得して必要があればファイルを開きなおすようにせれ
> 「必要があれば」を毎回算出するｺｽﾄと天秤にかけるよ
> つか、ﾛｸﾞﾌｧｲﾙとﾛｸﾞ内容の時間が多少ずれてもかまわんよ
> との許しがでたのでもう解決した(´ー｀)ゞ
> > たとえ優先度が低くても処理は回ってくるから同期はしっかり取れ
> 優先度と処理の配分に関しては、SetThreadPriorityのところに、
> 「同じ優先順位レベルに複数のスレッドが存在する場合、
> それらのスレッドはラウンドロビン形式でスケジューリングされ、
> より高いレベルの実行可能なスレッドが存在しない場合に限って、
> より低いレベルのスレッドが実行されます。」
> ってあるので、低いのは実行されないと思うんだけどちゃうのかな？(;´Д`)

あぁ
PSDKみたら確かに書いてあった
優先度が高いスレッドが譲渡またはブロックしない限り優先度が低いのは実行されないな

というか適当に書いてた俺は無駄骨ですか
時間の取得と比較ぐらいならそれ程コストはかからないモヨリ
というか眠いので寝ますヽ(´ー｀)ノじゃあなありがとう諸君

#include <stdio.h>
#include <windows.h>

int LogMessage(LPCTSTR message)
{
  static HANDLE log_file = NULL;
  static SYSTEMTIME previous_time;
  BOOL reopen_log = FALSE;
  DWORD bytes_written;

  if(!log_file) {
    GetLocalTime(&previous_time);
    reopen_log = TRUE;
  } else {
    SYSTEMTIME current_time;

    GetLocalTime(&current_time);
    if(previous_time.wYear != current_time.wYear ||
       previous_time.wMonth != current_time.wMonth ||
       previous_time.wDay != current_time.wDay ||
       previous_time.wHour != current_time.wHour ||
       previous_time.wMinute != current_time.wMinute) {
      reopen_log = TRUE;
      previous_time = current_time;
    }
  }

  if(reopen_log) {
    TCHAR filename[MAX_PATH];
    DWORD file_pointer;

    wsprintf(filename, TEXT("Log-%04d%02d%02d-%02d%02d.txt"),
      previous_time.wYear,
      previous_time.wMonth + 1,
      previous_time.wDay,
      previous_time.wHour,
      previous_time.wMinute
      );

    if(log_file) {
      CloseHandle(log_file);
    }

    log_file = CreateFile(filename, GENERIC_WRITE,
      FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if(!log_file) {
      return -1;
    }

    file_pointer = SetFilePointer(log_file, 0, NULL, FILE_END);
    if(file_pointer == INVALID_SET_FILE_POINTER) {
      return -1;
    }
  }

  if(!WriteFile(log_file, message, lstrlen(message)*sizeof(TCHAR), &bytes_written, NULL)) {
    return -1;
  }

  return bytes_written;
}

int main(void) {
  int i;

  for(i = 0; i < 10; i++) {
    char buf[100];

    wsprintf(buf, "Log %02d\r\n", i);
    printf("%s", buf);
    LogMessage(buf);
    Sleep(10000);
  }

  return 0;
}

参考：2001/10/11(木)16時29分08秒

＞　 2001/10/11 (木) 16:29:08　 ◆　 ▼　 ◇　 [mirai]

> > 時刻取得よりも、そこから現在ﾛｸﾞ吐くべきﾌｧｲﾙ名を
> > 算出して、それを開くという処理が結構重い。
> > そういうわけで、ﾛｸﾞﾌｧｲﾙはずっと開きっぱなしにしておいて、
> > 所定の時間ごとに書くべきﾌｧｲﾙのﾊﾝﾄﾞﾙを切り替える
> > みたいな処理にしたい。
> > これに関しては優先順位の高いｽﾚｯﾄﾞが待機してない状態であれば、ｽｹｼﾞｭｰﾘﾝｸﾞでそっちが優先されて低いのにはまったく割り当てられない
> > とMSDNの文書に書いてるので問題はないと思うんだ。
> > でもﾏﾙﾁﾌﾟﾛｾｯｻだとちょっとまずいかな(´ー｀;)？
> お前は根本的に間違っている
> ファイルは開いたままにしておいてログを書きこむときに
> 現在時刻を取得して必要があればファイルを開きなおすようにせれ

「必要があれば」を毎回算出するｺｽﾄと天秤にかけるよ

つか、ﾛｸﾞﾌｧｲﾙとﾛｸﾞ内容の時間が多少ずれてもかまわんよ
との許しがでたのでもう解決した(´ー｀)ゞ

> たとえ優先度が低くても処理は回ってくるから同期はしっかり取れ
優先度と処理の配分に関しては、SetThreadPriorityのところに、

「同じ優先順位レベルに複数のスレッドが存在する場合、
それらのスレッドはラウンドロビン形式でスケジューリングされ、
より高いレベルの実行可能なスレッドが存在しない場合に限って、
より低いレベルのスレッドが実行されます。」

ってあるので、低いのは実行されないと思うんだけどちゃうのかな？(;´Д`)

参考：2001/10/11(木)16時01分06秒

＞　 2001/10/11 (木) 16:01:06　 ◆　 ▼　 ◇　 [mirai]

> > 「そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたとき」ってのがよく分からんのだが
> > 毎回現在時刻を取得するコストってそんなに高かったかい？
> > 大体プリエンプティブでWM_TIMERを処理している最中にも
> > スレッドの切り替えは起こるわけだからスレッド間で
> > 共有されるものがあれば基本的に同期は必要だと思うが
> 時刻取得よりも、そこから現在ﾛｸﾞ吐くべきﾌｧｲﾙ名を
> 算出して、それを開くという処理が結構重い。
> そういうわけで、ﾛｸﾞﾌｧｲﾙはずっと開きっぱなしにしておいて、
> 所定の時間ごとに書くべきﾌｧｲﾙのﾊﾝﾄﾞﾙを切り替える
> みたいな処理にしたい。
> > 大体プリエンプティブでWM_TIMERを処理している最中にも
> > スレッドの切り替えは起こるわけだから
> これに関しては優先順位の高いｽﾚｯﾄﾞが待機してない状態であれば、ｽｹｼﾞｭｰﾘﾝｸﾞでそっちが優先されて低いのにはまったく割り当てられない
> とMSDNの文書に書いてるので問題はないと思うんだ。
> でもﾏﾙﾁﾌﾟﾛｾｯｻだとちょっとまずいかな(´ー｀;)？

お前は根本的に間違っている
ファイルは開いたままにしておいてログを書きこむときに
現在時刻を取得して必要があればファイルを開きなおすようにせれ

たとえ優先度が低くても処理は回ってくるから同期はしっかり取れ

参考：2001/10/11(木)15時52分46秒

＞　 2001/10/11 (木) 15:57:16　 ◆　 ▼　 ◇　 [mirai]

> > 「そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたとき」ってのがよく分からんのだが
> > 毎回現在時刻を取得するコストってそんなに高かったかい？
> > 大体プリエンプティブでWM_TIMERを処理している最中にも
> > スレッドの切り替えは起こるわけだからスレッド間で
> > 共有されるものがあれば基本的に同期は必要だと思うが
> 難しい話うぜえ難しい話うぜえ難しい話うぜえ難しい話うぜえ

読むなよ(;´Д`)

参考：2001/10/11(木)15時55分15秒

＞　 2001/10/11 (木) 15:55:15　 ◆　 ▼　 ◇　 [mirai]

> > ﾏﾙﾁﾒﾃﾞｨｱﾀｲﾏがのほうがいいとかそういう誤差の話は別に問題じゃなくて、
> > そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたときに他のｽﾚｯﾄﾞと同期をとらないといけない
> > ような状態であって欲しくないだけです(´ー｀)
> > つか、ﾛｸﾞ吐くﾌｧｲﾙを時間ごとに区切るといった処理なんだけど、なんか
> > いい方法ないかな。毎回毎回現在時刻から算出すると馬鹿になんねけよ。
> 「そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたとき」ってのがよく分からんのだが
> 毎回現在時刻を取得するコストってそんなに高かったかい？
> 大体プリエンプティブでWM_TIMERを処理している最中にも
> スレッドの切り替えは起こるわけだからスレッド間で
> 共有されるものがあれば基本的に同期は必要だと思うが

難しい話うぜえ難しい話うぜえ難しい話うぜえ難しい話うぜえ

参考：2001/10/11(木)15時37分52秒

＞　 2001/10/11 (木) 15:52:46　 ◆　 ▼　 ◇　 [mirai]

> > ﾏﾙﾁﾒﾃﾞｨｱﾀｲﾏがのほうがいいとかそういう誤差の話は別に問題じゃなくて、
> > そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたときに他のｽﾚｯﾄﾞと同期をとらないといけない
> > ような状態であって欲しくないだけです(´ー｀)
> > つか、ﾛｸﾞ吐くﾌｧｲﾙを時間ごとに区切るといった処理なんだけど、なんか
> > いい方法ないかな。毎回毎回現在時刻から算出すると馬鹿になんねけよ。
> 「そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたとき」ってのがよく分からんのだが
> 毎回現在時刻を取得するコストってそんなに高かったかい？
> 大体プリエンプティブでWM_TIMERを処理している最中にも
> スレッドの切り替えは起こるわけだからスレッド間で
> 共有されるものがあれば基本的に同期は必要だと思うが

時刻取得よりも、そこから現在ﾛｸﾞ吐くべきﾌｧｲﾙ名を
算出して、それを開くという処理が結構重い。
そういうわけで、ﾛｸﾞﾌｧｲﾙはずっと開きっぱなしにしておいて、
所定の時間ごとに書くべきﾌｧｲﾙのﾊﾝﾄﾞﾙを切り替える
みたいな処理にしたい。

> 大体プリエンプティブでWM_TIMERを処理している最中にも
> スレッドの切り替えは起こるわけだから
これに関しては優先順位の高いｽﾚｯﾄﾞが待機してない状態であれば、ｽｹｼﾞｭｰﾘﾝｸﾞでそっちが優先されて低いのにはまったく割り当てられない
とMSDNの文書に書いてるので問題はないと思うんだ。

でもﾏﾙﾁﾌﾟﾛｾｯｻだとちょっとまずいかな(´ー｀;)？

参考：2001/10/11(木)15時37分52秒

＞　 2001/10/11 (木) 15:37:52　 ◆　 ▼　 ◇　 [mirai]

> > WM_TIMERを信用してはいけないよ
> > Windowsのタイマーでも誤差がかなり大きい部類に入る
> ﾏﾙﾁﾒﾃﾞｨｱﾀｲﾏがのほうがいいとかそういう誤差の話は別に問題じゃなくて、
> そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたときに他のｽﾚｯﾄﾞと同期をとらないといけない
> ような状態であって欲しくないだけです(´ー｀)
> つか、ﾛｸﾞ吐くﾌｧｲﾙを時間ごとに区切るといった処理なんだけど、なんか
> いい方法ないかな。毎回毎回現在時刻から算出すると馬鹿になんねけよ。

「そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたとき」ってのがよく分からんのだが
毎回現在時刻を取得するコストってそんなに高かったかい？

大体プリエンプティブでWM_TIMERを処理している最中にも
スレッドの切り替えは起こるわけだからスレッド間で
共有されるものがあれば基本的に同期は必要だと思うが

参考：2001/10/11(木)15時32分16秒

＞　 2001/10/11 (木) 15:32:16　 ◆　 ▼　 ◇　 [mirai]

> > やっぱﾌﾟﾗｲｵﾘﾃｨの低いｽﾚｯﾄﾞもﾀｲﾑｽﾗｲｽ分までは動きつづけますかね(´ー`)？
> WM_TIMERを信用してはいけないよ
> Windowsのタイマーでも誤差がかなり大きい部類に入る

ﾏﾙﾁﾒﾃﾞｨｱﾀｲﾏがのほうがいいとかそういう誤差の話は別に問題じゃなくて、
そのﾒｯｾｰｼﾞでｽﾚｯﾄﾞがおきたときに他のｽﾚｯﾄﾞと同期をとらないといけない
ような状態であって欲しくないだけです(´ー｀)

つか、ﾛｸﾞ吐くﾌｧｲﾙを時間ごとに区切るといった処理なんだけど、なんか
いい方法ないかな。毎回毎回現在時刻から算出すると馬鹿になんねけよ。

参考：2001/10/11(木)15時25分21秒

＞　 2001/10/11 (木) 15:25:30　 ◆　 ▼　 ◇　 [mirai]

> > それはないと思う
> やっぱﾌﾟﾗｲｵﾘﾃｨの低いｽﾚｯﾄﾞもﾀｲﾑｽﾗｲｽ分までは動きつづけますかね(´ー`)？

それはあると思う

参考：2001/10/11(木)15時23分16秒

＞　 2001/10/11 (木) 15:25:21　 ◆　 ▼　 ◇　 [mirai]

> > それはないと思う
> やっぱﾌﾟﾗｲｵﾘﾃｨの低いｽﾚｯﾄﾞもﾀｲﾑｽﾗｲｽ分までは動きつづけますかね(´ー`)？

WM_TIMERを信用してはいけないよ
Windowsのタイマーでも誤差がかなり大きい部類に入る

参考：2001/10/11(木)15時23分16秒

＞　 2001/10/11 (木) 15:23:16　 ◆　 ▼　 ◇　 [mirai]

> > WM_TIMERをもらうｽﾚｯﾄﾞが同じﾌﾟﾛｾｽ内の他のｽﾚｯﾄﾞよりﾌﾟﾗｲｵﾘﾃｨが高いと、
> > ﾀｲﾏｰの所定の時間になったときｼｽﾃﾑはすぐに他のｽﾚｯﾄﾞをとめて、ﾒｯｾｰｼﾞを
> > くれると考えてよいですか(´ー`)？
> それはないと思う

やっぱﾌﾟﾗｲｵﾘﾃｨの低いｽﾚｯﾄﾞもﾀｲﾑｽﾗｲｽ分までは動きつづけますかね(´ー`)？

参考：2001/10/11(木)15時20分01秒

＞　 2001/10/11 (木) 15:20:01　 ◆　 ▼　 ◇　 [mirai]

> WM_TIMERをもらうｽﾚｯﾄﾞが同じﾌﾟﾛｾｽ内の他のｽﾚｯﾄﾞよりﾌﾟﾗｲｵﾘﾃｨが高いと、
> ﾀｲﾏｰの所定の時間になったときｼｽﾃﾑはすぐに他のｽﾚｯﾄﾞをとめて、ﾒｯｾｰｼﾞを
> くれると考えてよいですか(´ー`)？

それはないと思う

参考：2001/10/11(木)15時18分38秒

2001/10/11 (木) 15:18:38　 ◆　 ▼　 ◇　 [mirai]

WM_TIMERをもらうｽﾚｯﾄﾞが同じﾌﾟﾛｾｽ内の他のｽﾚｯﾄﾞよりﾌﾟﾗｲｵﾘﾃｨが高いと、
ﾀｲﾏｰの所定の時間になったときｼｽﾃﾑはすぐに他のｽﾚｯﾄﾞをとめて、ﾒｯｾｰｼﾞを
くれると考えてよいですか(´ー`)？

上へ