examplse : de-shadow

ggml-ci

Author: ggerganov

common/arg.cpp

@@ -17,19 +17,19 @@
 
 using json = nlohmann::ordered_json;
 
-common_arg & common_arg::set_examples(std::initializer_list<enum llama_example> examples) {
-    this->examples = std::move(examples);
+common_arg & common_arg::set_examples(std::initializer_list<enum llama_example> vals) {
+    examples = std::move(vals);
     return *this;
 }
 
-common_arg & common_arg::set_excludes(std::initializer_list<enum llama_example> excludes) {
-    this->excludes = std::move(excludes);
+common_arg & common_arg::set_excludes(std::initializer_list<enum llama_example> vals) {
+    excludes = std::move(vals);
     return *this;
 }
 
-common_arg & common_arg::set_env(const char * env) {
-    help = help + "\n(env: " + env + ")";
-    this->env = env;
+common_arg & common_arg::set_env(const char * val) {
+    help = help + "\n(env: " + val + ")";
+    env = val;
     return *this;
 }
 
@@ -46,8 +46,10 @@ bool common_arg::is_exclude(enum llama_example ex) {
     return excludes.find(ex) != excludes.end();
 }
 
-bool common_arg::get_value_from_env(std::string & output) {
-    if (env == nullptr) return false;
+bool common_arg::get_value_from_env(std::string & output) const {
+    if (env == nullptr) {
+        return false;
+    }
     char * value = std::getenv(env);
     if (value) {
         output = value;
@@ -56,7 +58,7 @@ bool common_arg::get_value_from_env(std::string & output) {
     return false;
 }
 
-bool common_arg::has_value_from_env() {
+bool common_arg::has_value_from_env() const {
     return env != nullptr && std::getenv(env);
 }
 
@@ -87,7 +89,7 @@ static std::vector<std::string> break_str_into_lines(std::string input, size_t m
     return result;
 }
 
-std::string common_arg::to_string() {
+std::string common_arg::to_string() const {
     // params for printing to console
     const static int n_leading_spaces = 40;
     const static int n_char_per_line_help = 70; // TODO: detect this based on current console
@@ -192,8 +194,6 @@ static std::string get_all_kv_cache_types() {
 //
 
 static bool common_params_parse_ex(int argc, char ** argv, common_params_context & ctx_arg) {
-    std::string arg;
-    const std::string arg_prefix = "--";
     common_params & params = ctx_arg.params;
 
     std::unordered_map<std::string, common_arg *> arg_to_options;

common/arg.h

@@ -53,15 +53,15 @@ struct common_arg {
         void (*handler)(common_params & params, const std::string &, const std::string &)
     ) : args(args), value_hint(value_hint), value_hint_2(value_hint_2), help(help), handler_str_str(handler) {}
 
-    common_arg & set_examples(std::initializer_list<enum llama_example> examples);
-    common_arg & set_excludes(std::initializer_list<enum llama_example> excludes);
-    common_arg & set_env(const char * env);
+    common_arg & set_examples(std::initializer_list<enum llama_example> vals);
+    common_arg & set_excludes(std::initializer_list<enum llama_example> vals);
+    common_arg & set_env(const char * val);
     common_arg & set_sparam();
     bool in_example(enum llama_example ex);
     bool is_exclude(enum llama_example ex);
-    bool get_value_from_env(std::string & output);
-    bool has_value_from_env();
-    std::string to_string();
+    bool get_value_from_env(std::string & output) const;
+    bool has_value_from_env() const;
+    std::string to_string() const;
 };
 
 struct common_params_context {

common/common.cpp

@@ -763,9 +763,11 @@ bool fs_create_directory_with_parents(const std::string & path) {
     return true;
 #else
     // if the path already exists, check whether it's a directory
-    struct stat info;
-    if (stat(path.c_str(), &info) == 0) {
-        return S_ISDIR(info.st_mode);
+    {
+        struct stat info;
+        if (stat(path.c_str(), &info) == 0) {
+            return S_ISDIR(info.st_mode);
+        }
     }
 
     size_t pos_slash = 1; // skip leading slashes for directory creation
@@ -796,7 +798,7 @@ bool fs_create_directory_with_parents(const std::string & path) {
 }
 
 std::string fs_get_cache_directory() {
-    std::string cache_directory = "";
+    std::string cache_directory;
     auto ensure_trailing_slash = [](std::string p) {
         // Make sure to add trailing slash
         if (p.back() != DIRECTORY_SEPARATOR) {

common/console.cpp

@@ -43,7 +43,7 @@ namespace console {
     static bool      simple_io        = true;
     static display_t current_display  = reset;
 
-    static FILE*     out              = stdout;
+    static FILE*     fout             = stdout;
 
 #if defined (_WIN32)
     static void*     hConsole;
@@ -110,7 +110,7 @@ namespace console {
 
             tty = fopen("/dev/tty", "w+");
             if (tty != nullptr) {
-                out = tty;
+                fout = tty;
             }
         }
 
@@ -126,7 +126,7 @@ namespace console {
         // Restore settings on POSIX systems
         if (!simple_io) {
             if (tty != nullptr) {
-                out = stdout;
+                fout = stdout;
                 fclose(tty);
                 tty = nullptr;
             }
@@ -145,19 +145,19 @@ namespace console {
             fflush(stdout);
             switch(display) {
                 case reset:
-                    fprintf(out, ANSI_COLOR_RESET);
+                    fprintf(fout, ANSI_COLOR_RESET);
                     break;
                 case prompt:
-                    fprintf(out, ANSI_COLOR_YELLOW);
+                    fprintf(fout, ANSI_COLOR_YELLOW);
                     break;
                 case user_input:
-                    fprintf(out, ANSI_BOLD ANSI_COLOR_GREEN);
+                    fprintf(fout, ANSI_BOLD ANSI_COLOR_GREEN);
                     break;
                 case error:
-                    fprintf(out, ANSI_BOLD ANSI_COLOR_RED);
+                    fprintf(fout, ANSI_BOLD ANSI_COLOR_RED);
             }
             current_display = display;
-            fflush(out);
+            fflush(fout);
         }
     }
 
@@ -233,7 +233,7 @@ namespace console {
             return;
         }
 #endif
-        putc('\b', out);
+        putc('\b', fout);
     }
 
     static int estimateWidth(char32_t codepoint) {
@@ -274,7 +274,7 @@ namespace console {
 #else
         // We can trust expectedWidth if we've got one
         if (expectedWidth >= 0 || tty == nullptr) {
-            fwrite(utf8_codepoint, length, 1, out);
+            fwrite(utf8_codepoint, length, 1, fout);
             return expectedWidth;
         }
 
@@ -311,7 +311,7 @@ namespace console {
         pop_cursor();
         put_codepoint(&ch, 1, 1);
 #else
-        fprintf(out, "\b%c", ch);
+        fprintf(fout, "\b%c", ch);
 #endif
     }
 
@@ -353,7 +353,7 @@ namespace console {
     }
 
     static bool readline_advanced(std::string & line, bool multiline_input) {
-        if (out != stdout) {
+        if (fout != stdout) {
             fflush(stdout);
         }
 
@@ -364,7 +364,7 @@ namespace console {
 
         char32_t input_char;
         while (true) {
-            fflush(out); // Ensure all output is displayed before waiting for input
+            fflush(fout); // Ensure all output is displayed before waiting for input
             input_char = getchar32();
 
             if (input_char == '\r' || input_char == '\n') {
@@ -432,7 +432,7 @@ namespace console {
             line.pop_back();
             if (last == '\\') {
                 line += '\n';
-                fputc('\n', out);
+                fputc('\n', fout);
                 has_more = !has_more;
             } else {
                 // llama will just eat the single space, it won't act as a space
@@ -447,11 +447,11 @@ namespace console {
                 has_more = false;
             } else {
                 line += '\n';
-                fputc('\n', out);
+                fputc('\n', fout);
             }
         }
 
-        fflush(out);
+        fflush(fout);
         return has_more;
     }
 

common/log.cpp

@@ -338,16 +338,16 @@ struct common_log {
         resume();
     }
 
-    void set_prefix(bool prefix) {
+    void set_prefix(bool val) {
         std::lock_guard<std::mutex> lock(mtx);
 
-        this->prefix = prefix;
+        prefix = val;
     }
 
-    void set_timestamps(bool timestamps) {
+    void set_timestamps(bool val) {
         std::lock_guard<std::mutex> lock(mtx);
 
-        this->timestamps = timestamps;
+        timestamps = val;
     }
 };
 

examples/convert-llama2c-to-ggml/convert-llama2c-to-ggml.cpp

@@ -471,12 +471,12 @@ struct my_llama_file {
         GGML_ASSERT(ret == 0); // same
     }
 
-    void read_raw(void * ptr, size_t size) {
-        if (size == 0) {
+    void read_raw(void * ptr, size_t size_cur) {
+        if (size_cur == 0) {
             return;
         }
         errno = 0;
-        std::size_t ret = std::fread(ptr, size, 1, fp);
+        std::size_t ret = std::fread(ptr, size_cur, 1, fp);
         if (ferror(fp)) {
             die_fmt("fread failed: %s", strerror(errno));
         }

examples/gbnf-validator/gbnf-validator.cpp

@@ -60,13 +60,6 @@ int main(int argc, char** argv) {
     const std::string grammar_filename = argv[1];
     const std::string input_filename = argv[2];
 
-    // Read the GBNF grammar file
-    FILE* grammar_file = fopen(grammar_filename.c_str(), "r");
-    if (!grammar_file) {
-        fprintf(stdout, "Failed to open grammar file: %s\n", grammar_filename.c_str());
-        return 1;
-    }
-
     std::string grammar_str;
     {
         std::ifstream grammar_file(grammar_filename);

examples/imatrix/imatrix.cpp

@@ -294,7 +294,7 @@ void IMatrixCollector::save_imatrix(int ncall) const {
 bool IMatrixCollector::load_imatrix(const char * fname) {
     std::ifstream in(fname, std::ios::binary);
     if (!in) {
-        LOG_ERR("%s: failed to open %s\n",__func__, fname);
+        LOG_ERR("%s: failed to open %s\n", __func__, fname);
         return false;
     }
     int n_entries;
@@ -308,7 +308,7 @@ bool IMatrixCollector::load_imatrix(const char * fname) {
         std::vector<char> name_as_vec(len+1);
         in.read((char *)name_as_vec.data(), len);
         if (in.fail()) {
-            LOG_ERR("%s: failed reading name for entry %d from %s\n",__func__,i+1, fname);
+            LOG_ERR("%s: failed reading name for entry %d from %s\n", __func__, i + 1, fname);
             return false;
         }
         name_as_vec[len] = 0;
@@ -319,7 +319,7 @@ bool IMatrixCollector::load_imatrix(const char * fname) {
         int nval;
         in.read((char *)&nval, sizeof(nval));
         if (in.fail() || nval < 1) {
-            LOG_ERR("%s: failed reading number of values for entry %d\n",__func__,i);
+            LOG_ERR("%s: failed reading number of values for entry %d\n", __func__, i);
             m_stats = {};
             return false;
         }
@@ -332,15 +332,15 @@ bool IMatrixCollector::load_imatrix(const char * fname) {
         std::vector<float> tmp(nval);
         in.read((char*)tmp.data(), nval*sizeof(float));
         if (in.fail()) {
-            LOG_ERR("%s: failed reading data for entry %d\n",__func__,i);
+            LOG_ERR("%s: failed reading data for entry %d\n", __func__, i);
             m_stats = {};
             return false;
         }
 
         // Recreate the state as expected by save_imatrix(), and corerct for weighted sum.
-        for (int i = 0; i < nval; i++) {
-            e.values[i] += tmp[i];
-            e.counts[i] += ncall;
+        for (int j = 0; j < nval; j++) {
+            e.values[j] += tmp[j];
+            e.counts[j] += ncall;
         }
         e.ncall += ncall;
 
@@ -488,12 +488,10 @@ static bool compute_imatrix(llama_context * ctx, const common_params & params) {
         logits.reserve((size_t)n_ctx * n_vocab);
     }
 
-    for (int i = 0; i < n_chunk; ++i) {
-        const int start =     i * n_ctx;
+    for (int ich = 0; ich < n_chunk; ++ich) {
+        const int start =   ich * n_ctx;
         const int end   = start + n_ctx;
 
-        std::vector<float> logits;
-
         const auto t_start = std::chrono::high_resolution_clock::now();
 
         // clear the KV cache
@@ -537,7 +535,7 @@ static bool compute_imatrix(llama_context * ctx, const common_params & params) {
 
         const auto t_end = std::chrono::high_resolution_clock::now();
 
-        if (i == 0) {
+        if (ich == 0) {
             const float t_total = std::chrono::duration<float>(t_end - t_start).count();
             LOG_INF("%s: %.2f seconds per pass - ETA ", __func__, t_total);
             int total_seconds = (int)(t_total * n_chunk);
@@ -555,7 +553,7 @@ static bool compute_imatrix(llama_context * ctx, const common_params & params) {
                     workers, nll, nll2, logit_history.data() + start + first, prob_history.data() + start + first);
             count += n_ctx - first - 1;
 
-            LOG("[%d]%.4lf,", i + 1, std::exp(nll / count));
+            LOG("[%d]%.4lf,", ich + 1, std::exp(nll / count));
             fflush(stdout);
 
             logits.clear();

examples/infill/infill.cpp

@@ -462,14 +462,14 @@ int main(int argc, char ** argv) {
                 }
 
                 // tokenize new prefix and suffix
-                std::vector<llama_token> inp_pfx = common_tokenize(ctx, params.input_prefix, false);
-                std::vector<llama_token> inp_sfx = common_tokenize(ctx, params.input_suffix, false);
+                std::vector<llama_token> inp_pfx_cur = common_tokenize(ctx, params.input_prefix, false);
+                std::vector<llama_token> inp_sfx_cur = common_tokenize(ctx, params.input_suffix, false);
 
-                inp_pfx.insert(inp_pfx.begin(), llama_vocab_fim_pre(vocab));
-                inp_sfx.insert(inp_sfx.begin(), llama_vocab_fim_suf(vocab));
+                inp_pfx_cur.insert(inp_pfx_cur.begin(), llama_vocab_fim_pre(vocab));
+                inp_sfx_cur.insert(inp_sfx_cur.begin(), llama_vocab_fim_suf(vocab));
 
-                embd_inp = params.spm_infill ? inp_sfx : inp_pfx;
-                embd_end = params.spm_infill ? inp_pfx : inp_sfx;
+                embd_inp = params.spm_infill ? inp_sfx_cur : inp_pfx_cur;
+                embd_end = params.spm_infill ? inp_pfx_cur : inp_sfx_cur;
                 if (add_bos) {
                     embd_inp.insert(embd_inp.begin(), llama_vocab_bos(vocab));
                 }