llama : rename batch.logits to batch.output

danbev · danbev · commit 291a7855873c · 2025-02-05T05:47:57.000+01:00
This commit renames the `logits` field of the `llama_batch` struct to
`output`.

The motivation for this change (apart from the TODO comment) is that
the `logits` field is actually used to specify that output should be
generated. For example, in the case of generating embeddings, setting
logits to true can be confusing since the logits are not used when
generating embeddings.
diff --git a/common/common.cpp b/common/common.cpp
@@ -607,7 +607,7 @@ std::string string_from(const struct llama_context * ctx, const struct llama_bat
             << ", pos "      << std::to_string(batch.pos[i])
             << ", n_seq_id " << std::to_string(batch.n_seq_id[i])
             << ", seq_id "   << std::to_string(batch.seq_id[i][0])
-            << ", logits "   << std::to_string(batch.logits[i]);
+            << ", output "   << std::to_string(batch.output[i]);
     }
 
     buf << " ]";
@@ -1617,7 +1617,7 @@ void common_batch_add(
                         llama_token   id,
                           llama_pos   pos,
     const std::vector<llama_seq_id> & seq_ids,
-                               bool   logits) {
+                               bool   output) {
     GGML_ASSERT(batch.seq_id[batch.n_tokens] && "llama_batch size exceeded");
 
     batch.token   [batch.n_tokens] = id;
@@ -1626,7 +1626,7 @@ void common_batch_add(
     for (size_t i = 0; i < seq_ids.size(); ++i) {
         batch.seq_id[batch.n_tokens][i] = seq_ids[i];
     }
-    batch.logits  [batch.n_tokens] = logits;
+    batch.output  [batch.n_tokens] = output;
 
     batch.n_tokens++;
 }
diff --git a/examples/batched-bench/batched-bench.cpp b/examples/batched-bench/batched-bench.cpp
@@ -73,7 +73,7 @@ int main(int argc, char ** argv) {
                 batch.pos      + i,
                 batch.n_seq_id + i,
                 batch.seq_id   + i,
-                batch.logits   + i,
+                batch.output   + i,
             };
 
             const int ret = llama_decode(ctx, batch_view);
@@ -128,7 +128,7 @@ int main(int argc, char ** argv) {
                         common_batch_add(batch, 0, i, { j }, false);
                     }
                 }
-                batch.logits[batch.n_tokens - 1] = true;
+                batch.output[batch.n_tokens - 1] = true;
 
                 const auto t_pp_start = ggml_time_us();
 
diff --git a/examples/batched.swift/Sources/main.swift b/examples/batched.swift/Sources/main.swift
@@ -104,11 +104,11 @@ for (i, token) in tokens.enumerated() {
     if let seq_id = batch.seq_id[i] {
         seq_id[0] = 0
     }
-    batch.logits[i] = 0
+    batch.output[i] = 0
 }
 
 // llama_decode will output logits only for the last token of the prompt
-batch.logits[Int(batch.n_tokens) - 1] = 1
+batch.output[Int(batch.n_tokens) - 1] = 1
 
 if llama_decode(context, batch) != 0 {
     print("llama_decode() failed")
@@ -171,7 +171,7 @@ while n_cur <= n_len {
         if let seq_id = batch.seq_id[Int(batch.n_tokens)] {
             seq_id[0] = Int32(i)
         }
-        batch.logits[Int(batch.n_tokens)] = 1
+        batch.output[Int(batch.n_tokens)] = 1
 
         i_batch[i] = batch.n_tokens
 
diff --git a/examples/batched/batched.cpp b/examples/batched/batched.cpp
@@ -131,7 +131,7 @@ int main(int argc, char ** argv) {
     }
 
     // llama_decode will output logits only for the last token of the prompt
-    batch.logits[batch.n_tokens - 1] = true;
+    batch.output[batch.n_tokens - 1] = true;
 
     if (llama_decode(ctx, batch) != 0) {
         LOG_ERR("%s: llama_decode() failed\n", __func__);
diff --git a/examples/embedding/embedding.cpp b/examples/embedding/embedding.cpp
@@ -54,7 +54,7 @@ static void batch_decode(llama_context * ctx, llama_batch & batch, float * outpu
     }
 
     for (int i = 0; i < batch.n_tokens; i++) {
-        if (!batch.logits[i]) {
+        if (!batch.output[i]) {
             continue;
         }
 
diff --git a/examples/llama.android/llama/src/main/cpp/llama-android.cpp b/examples/llama.android/llama/src/main/cpp/llama-android.cpp
@@ -193,7 +193,7 @@ Java_android_llama_cpp_LLamaAndroid_bench_1model(
             common_batch_add(*batch, 0, i, { 0 }, false);
         }
 
-        batch->logits[batch->n_tokens - 1] = true;
+        batch->output[batch->n_tokens - 1] = true;
         llama_kv_cache_clear(context);
 
         const auto t_pp_start = ggml_time_us();
@@ -297,7 +297,7 @@ Java_android_llama_cpp_LLamaAndroid_new_1batch(JNIEnv *, jobject, jint n_tokens,
     for (int i = 0; i < n_tokens; ++i) {
         batch->seq_id[i] = (llama_seq_id *) malloc(sizeof(llama_seq_id) * n_seq_max);
     }
-    batch->logits   = (int8_t *)        malloc(sizeof(int8_t)         * n_tokens);
+    batch->output   = (int8_t *)        malloc(sizeof(int8_t)         * n_tokens);
 
     return reinterpret_cast<jlong>(batch);
 }
@@ -381,7 +381,7 @@ Java_android_llama_cpp_LLamaAndroid_completion_1init(
     }
 
     // llama_decode will output logits only for the last token of the prompt
-    batch->logits[batch->n_tokens - 1] = true;
+    batch->output[batch->n_tokens - 1] = true;
 
     if (llama_decode(context, *batch) != 0) {
         LOGe("llama_decode() failed");
diff --git a/examples/llama.swiftui/llama.cpp.swift/LibLlama.swift b/examples/llama.swiftui/llama.cpp.swift/LibLlama.swift
@@ -9,14 +9,14 @@ func llama_batch_clear(_ batch: inout llama_batch) {
     batch.n_tokens = 0
 }
 
-func llama_batch_add(_ batch: inout llama_batch, _ id: llama_token, _ pos: llama_pos, _ seq_ids: [llama_seq_id], _ logits: Bool) {
+func llama_batch_add(_ batch: inout llama_batch, _ id: llama_token, _ pos: llama_pos, _ seq_ids: [llama_seq_id], _ outputs: Bool) {
     batch.token   [Int(batch.n_tokens)] = id
     batch.pos     [Int(batch.n_tokens)] = pos
     batch.n_seq_id[Int(batch.n_tokens)] = Int32(seq_ids.count)
     for i in 0..<seq_ids.count {
         batch.seq_id[Int(batch.n_tokens)]![Int(i)] = seq_ids[i]
     }
-    batch.logits  [Int(batch.n_tokens)] = logits ? 1 : 0
+    batch.outputs  [Int(batch.n_tokens)] = outputs ? 1 : 0
 
     batch.n_tokens += 1
 }
@@ -139,7 +139,7 @@ actor LlamaContext {
             let i = Int(i1)
             llama_batch_add(&batch, tokens_list[i], Int32(i), [0], false)
         }
-        batch.logits[Int(batch.n_tokens) - 1] = 1 // true
+        batch.output[Int(batch.n_tokens) - 1] = 1 // true
 
         if llama_decode(context, batch) != 0 {
             print("llama_decode() failed")
@@ -208,7 +208,7 @@ actor LlamaContext {
             for i in 0..<n_tokens {
                 llama_batch_add(&batch, 0, Int32(i), [0], false)
             }
-            batch.logits[Int(batch.n_tokens) - 1] = 1 // true
+            batch.output[Int(batch.n_tokens) - 1] = 1 // true
 
             llama_kv_cache_clear(context)
 
diff --git a/examples/llava/llava.cpp b/examples/llava/llava.cpp
@@ -441,13 +441,13 @@ struct llava_embd_batch {
     std::vector<int32_t>        n_seq_id;
     std::vector<llama_seq_id>   seq_id_0;
     std::vector<llama_seq_id *> seq_ids;
-    std::vector<int8_t>         logits;
+    std::vector<int8_t>         outputs;
     llama_batch batch;
     llava_embd_batch(float * embd, int32_t n_tokens, llama_pos pos_0, llama_seq_id seq_id) {
         pos     .resize(n_tokens);
         n_seq_id.resize(n_tokens);
         seq_ids .resize(n_tokens + 1);
-        logits  .resize(n_tokens);
+        outputs .resize(n_tokens);
         seq_id_0.resize(1);
         seq_id_0[0] = seq_id;
         seq_ids [n_tokens] = nullptr;
@@ -458,13 +458,13 @@ struct llava_embd_batch {
             /*pos            =*/ pos.data(),
             /*n_seq_id       =*/ n_seq_id.data(),
             /*seq_id         =*/ seq_ids.data(),
-            /*logits         =*/ logits.data(),
+            /*output         =*/ outputs.data(),
         };
         for (int i = 0; i < n_tokens; i++) {
             batch.pos     [i] = pos_0 + i;
             batch.n_seq_id[i] = 1;
             batch.seq_id  [i] = seq_id_0.data();
-            batch.logits  [i] = false;
+            batch.output  [i] = false;
         }
     }
 };
diff --git a/examples/parallel/parallel.cpp b/examples/parallel/parallel.cpp
@@ -266,7 +266,7 @@ int main(int argc, char ** argv) {
 
                     // extract the logits only for the last token
                     if (batch.n_tokens > 0) {
-                        batch.logits[batch.n_tokens - 1] = true;
+                        batch.output[batch.n_tokens - 1] = true;
                     }
 
                     client.n_prompt  = tokens_prompt.size();
@@ -309,7 +309,7 @@ int main(int argc, char ** argv) {
                 batch.pos      + i,
                 batch.n_seq_id + i,
                 batch.seq_id   + i,
-                batch.logits   + i,
+                batch.output   + i,
             };
 
             const int ret = llama_decode(ctx, batch_view);
diff --git a/examples/passkey/passkey.cpp b/examples/passkey/passkey.cpp
@@ -146,7 +146,7 @@ int main(int argc, char ** argv) {
         }
 
         if (i + n_batch >= n_tokens_all) {
-            batch.logits[batch.n_tokens - 1] = true;
+            batch.output[batch.n_tokens - 1] = true;
         }
 
         if (llama_decode(ctx, batch) != 0) {
@@ -180,7 +180,7 @@ int main(int argc, char ** argv) {
         }
 
         if (i + n_batch >= n_tokens_all) {
-            batch.logits[batch.n_tokens - 1] = true;
+            batch.output[batch.n_tokens - 1] = true;
         }
 
         if (llama_decode(ctx, batch) != 0) {
diff --git a/examples/perplexity/perplexity.cpp b/examples/perplexity/perplexity.cpp
@@ -572,9 +572,9 @@ static results_perplexity perplexity(llama_context * ctx, const common_params &
                     batch.pos     [idx]    = j*n_batch + k;
                     batch.n_seq_id[idx]    = 1;
                     batch.seq_id  [idx][0] = seq;
-                    batch.logits  [idx]    = batch.pos[idx] >= first ? 1 : 0;
+                    batch.output  [idx]    = batch.pos[idx] >= first ? 1 : 0;
 
-                    n_outputs += batch.logits[idx] != 0;
+                    n_outputs += batch.output[idx] != 0;
                 }
                 batch.n_tokens += batch_size;
 
@@ -669,7 +669,7 @@ static bool decode_helper(llama_context * ctx, llama_batch & batch, std::vector<
             batch.pos      + i,
             batch.n_seq_id + i,
             batch.seq_id   + i,
-            batch.logits   + i,
+            batch.output   + i,
         };
 
         const int ret = llama_decode(ctx, batch_view);
@@ -680,7 +680,7 @@ static bool decode_helper(llama_context * ctx, llama_batch & batch, std::vector<
 
         int n_outputs = 0;
         for (int i = 0; i < n_tokens; ++i) {
-            n_outputs += batch_view.logits[i] != 0;
+            n_outputs += batch_view.output[i] != 0;
         }
 
         memcpy(batch_logits.data() + size_t(prev_outputs)*n_vocab, llama_get_logits(ctx), size_t(n_outputs)*n_vocab*sizeof(float));
@@ -896,7 +896,7 @@ static void hellaswag_score(llama_context * ctx, const common_params & params) {
             for (size_t i = 0; i < hs_cur.common_prefix; ++i) {
                 common_batch_add(batch, hs_cur.seq_tokens[0][i], i, { s0 + 0, s0 + 1, s0 + 2, s0 + 3 }, false);
             }
-            batch.logits[batch.n_tokens - 1] = true; // we need logits for the last token of the common prefix
+            batch.output[batch.n_tokens - 1] = true; // we need logits for the last token of the common prefix
             n_logits += 1;
 
             for (int s = 0; s < 4; ++s) {
@@ -1177,7 +1177,7 @@ static void winogrande_score(llama_context * ctx, const common_params & params)
             for (size_t i = 0; i < data[i1].common_prefix; ++i) {
                 common_batch_add(batch, data[i1].seq_tokens[0][i], i, { s0 + 0, s0 + 1 }, false);
             }
-            batch.logits[batch.n_tokens - 1] = true;
+            batch.output[batch.n_tokens - 1] = true;
             n_logits += 1;
 
             for (int s = 0; s < 2; ++s) {
@@ -1545,7 +1545,7 @@ static void multiple_choice_score(llama_context * ctx, const common_params & par
                 //llama_batch_add(batch, cur_task.seq_tokens[0][i], i, { s0 + 0, s0 + 1, s0 + 2, s0 + 3}, false);
                 common_batch_add(batch, cur_task.seq_tokens[0][i], i, batch_indeces, false);
             }
-            batch.logits[batch.n_tokens - 1] = true; // we need logits for the last token of the common prefix
+            batch.output[batch.n_tokens - 1] = true; // we need logits for the last token of the common prefix
             n_logits += 1;
 
             for (int s = 0; s < int(cur_task.seq_tokens.size()); ++s) {
diff --git a/examples/retrieval/retrieval.cpp b/examples/retrieval/retrieval.cpp
@@ -92,7 +92,7 @@ static void batch_decode(llama_context * ctx, llama_batch & batch, float * outpu
     }
 
     for (int i = 0; i < batch.n_tokens; i++) {
-        if (!batch.logits[i]) {
+        if (!batch.output[i]) {
             continue;
         }
 
diff --git a/examples/save-load-state/save-load-state.cpp b/examples/save-load-state/save-load-state.cpp
@@ -52,7 +52,7 @@ int main(int argc, char ** argv) {
     for (size_t i = 0; i < tokens.size(); i++) {
         common_batch_add(batch, tokens[i], i, {0}, false);
     }
-    batch.logits[batch.n_tokens - 1] = true; // generate next token
+    batch.output[batch.n_tokens - 1] = true; // generate next token
 
     // evaluate prompt
     llama_decode(ctx, batch);
diff --git a/examples/server/server.cpp b/examples/server/server.cpp
@@ -2413,7 +2413,7 @@ struct server_context {
         std::vector<float> embd_res(n_embd, 0.0f);
 
         for (int i = 0; i < batch.n_tokens; ++i) {
-            if (!batch.logits[i] || batch.seq_id[i][0] != slot.id) {
+            if (!batch.output[i] || batch.seq_id[i][0] != slot.id) {
                 continue;
             }
 
@@ -2451,7 +2451,7 @@ struct server_context {
         res->n_tokens = slot.n_prompt_tokens;
 
         for (int i = 0; i < batch.n_tokens; ++i) {
-            if (!batch.logits[i] || batch.seq_id[i][0] != slot.id) {
+            if (!batch.output[i] || batch.seq_id[i][0] != slot.id) {
                 continue;
             }
 
@@ -3109,7 +3109,7 @@ struct server_context {
                         }
 
                         // extract the logits only for the last token
-                        batch.logits[batch.n_tokens - 1] = true;
+                        batch.output[batch.n_tokens - 1] = true;
 
                         slot.n_decoded = 0;
                         slot.i_batch   = batch.n_tokens - 1;
@@ -3149,7 +3149,7 @@ struct server_context {
                 batch.pos      + i,
                 batch.n_seq_id + i,
                 batch.seq_id   + i,
-                batch.logits   + i,
+                batch.output   + i,
             };
 
             const int ret = llama_decode(ctx, batch_view);
diff --git a/examples/tts/tts.cpp b/examples/tts/tts.cpp
@@ -722,7 +722,7 @@ lovely<|t_0.56|><|code_start|><|634|><|596|><|1766|><|1556|><|1306|><|1285|><|14
         GGML_ASSERT(batch.n_tokens == (int) prompt_inp.size());
 
         // llama_decode will output logits only for the last token of the prompt
-        batch.logits[batch.n_tokens - 1] = true;
+        batch.output[batch.n_tokens - 1] = true;
 
         if (llama_decode(ctx_ttc, batch) != 0) {
             LOG_ERR("%s: llama_decode() failed\n", __func__);
diff --git a/include/llama.h b/include/llama.h
@@ -252,7 +252,7 @@ extern "C" {
         llama_pos    *  pos;
         int32_t      *  n_seq_id;
         llama_seq_id ** seq_id;
-        int8_t       *  logits; // TODO: rename this to "output"
+        int8_t       *  output;
     } llama_batch;
 
     enum llama_model_kv_override_type {
diff --git a/src/llama-batch.cpp b/src/llama-batch.cpp
@@ -102,17 +102,17 @@ void llama_sbatch::add_seq_to_ubatch(llama_ubatch & ubatch, llama_sbatch_seq & s
             ubatch.output[ubatch.n_tokens + i] = 1;
             out_ids.push_back(ids[seq.offset + i]);
         }
-    } else if (batch->logits) {
+    } else if (batch->output) {
         if (ubatch.equal_seqs) {
             for (size_t i = 0; i < length; ++i) {
                 size_t id = ids[seq.offset + i];
-                int8_t is_output = batch->logits[id];
+                int8_t is_output = batch->output[id];
                 ubatch.output[ubatch.n_tokens + i] = is_output;
                 if (is_output) { out_ids.push_back(id); }
             }
         } else {
             // simple split
-            ubatch.output = batch->logits + seq.offset;
+            ubatch.output = batch->output + seq.offset;
             for (size_t i = 0; i < length; ++i) {
                 if (ubatch.output[i] != 0) { out_ids.push_back(seq.offset + i); }
             }
@@ -298,10 +298,10 @@ llama_batch_allocr::llama_batch_allocr(struct llama_batch in_batch, llama_pos p0
         }
         batch.seq_id = seq_id.data();
     }
-    if (!batch.logits) {
-        logits.resize(batch.n_tokens);
-        logits[logits.size() - 1] = true;
-        batch.logits = logits.data();
+    if (!batch.output) {
+        outputs.resize(batch.n_tokens);
+        outputs[outputs.size() - 1] = true;
+        batch.output = outputs.data();
     }
 }
 
@@ -348,7 +348,7 @@ struct llama_batch llama_batch_init(int32_t n_tokens_alloc, int32_t embd, int32_
     }
     batch.seq_id[n_tokens_alloc] = nullptr;
 
-    batch.logits   = (int8_t *)        malloc(sizeof(int8_t)         * n_tokens_alloc);
+    batch.output   = (int8_t *)        malloc(sizeof(int8_t)         * n_tokens_alloc);
 
     return batch;
 }
@@ -364,5 +364,5 @@ void llama_batch_free(struct llama_batch batch) {
         }
         free(batch.seq_id);
     }
-    if (batch.logits)   free(batch.logits);
+    if (batch.output)   free(batch.output);
 }
diff --git a/src/llama-batch.h b/src/llama-batch.h
diff --git a/src/llama.cpp b/src/llama.cpp

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ int main(int argc, char ** argv) {`
`73`	`73`	`batch.pos + i,`
`74`	`74`	`batch.n_seq_id + i,`
`75`	`75`	`batch.seq_id + i,`
`76`		`- batch.logits + i,`
	`76`	`+ batch.output + i,`
`77`	`77`	`};`
`78`	`78`
`79`	`79`	`const int ret = llama_decode(ctx, batch_view);`
`@@ -128,7 +128,7 @@ int main(int argc, char ** argv) {`
`128`	`128`	`common_batch_add(batch, 0, i, { j }, false);`
`129`	`129`	`}`
`130`	`130`	`}`
`131`		`- batch.logits[batch.n_tokens - 1] = true;`
	`131`	`+ batch.output[batch.n_tokens - 1] = true;`
`132`	`132`
`133`	`133`	`const auto t_pp_start = ggml_time_us();`
`134`	`134`
Original file line number	Diff line number	Diff line change
`@@ -104,11 +104,11 @@ for (i, token) in tokens.enumerated() {`
`104`	`104`	`if let seq_id = batch.seq_id[i] {`
`105`	`105`	`seq_id[0] = 0`
`106`	`106`	`}`
`107`		`- batch.logits[i] = 0`
	`107`	`+ batch.output[i] = 0`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`// llama_decode will output logits only for the last token of the prompt`
`111`		`-batch.logits[Int(batch.n_tokens) - 1] = 1`
	`111`	`+batch.output[Int(batch.n_tokens) - 1] = 1`
`112`	`112`
`113`	`113`	`if llama_decode(context, batch) != 0 {`
`114`	`114`	`print("llama_decode() failed")`
`@@ -171,7 +171,7 @@ while n_cur <= n_len {`
`171`	`171`	`if let seq_id = batch.seq_id[Int(batch.n_tokens)] {`
`172`	`172`	`seq_id[0] = Int32(i)`
`173`	`173`	`}`
`174`		`- batch.logits[Int(batch.n_tokens)] = 1`
	`174`	`+ batch.output[Int(batch.n_tokens)] = 1`
`175`	`175`
`176`	`176`	`i_batch[i] = batch.n_tokens`
`177`	`177`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ int main(int argc, char ** argv) {`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`// llama_decode will output logits only for the last token of the prompt`
`134`		`- batch.logits[batch.n_tokens - 1] = true;`
	`134`	`+ batch.output[batch.n_tokens - 1] = true;`
`135`	`135`
`136`	`136`	`if (llama_decode(ctx, batch) != 0) {`
`137`	`137`	`LOG_ERR("%s: llama_decode() failed\n", __func__);`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ static void batch_decode(llama_context * ctx, llama_batch & batch, float * outpu`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`for (int i = 0; i < batch.n_tokens; i++) {`
`57`		`- if (!batch.logits[i]) {`
	`57`	`+ if (!batch.output[i]) {`
`58`	`58`	`continue;`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ Java_android_llama_cpp_LLamaAndroid_bench_1model(`
`193`	`193`	`common_batch_add(*batch, 0, i, { 0 }, false);`
`194`	`194`	`}`
`195`	`195`
`196`		`- batch->logits[batch->n_tokens - 1] = true;`
	`196`	`+ batch->output[batch->n_tokens - 1] = true;`
`197`	`197`	`llama_kv_cache_clear(context);`
`198`	`198`
`199`	`199`	`const auto t_pp_start = ggml_time_us();`
`@@ -297,7 +297,7 @@ Java_android_llama_cpp_LLamaAndroid_new_1batch(JNIEnv *, jobject, jint n_tokens,`
`297`	`297`	`for (int i = 0; i < n_tokens; ++i) {`
`298`	`298`	`batch->seq_id[i] = (llama_seq_id ) malloc(sizeof(llama_seq_id) n_seq_max);`
`299`	`299`	`}`
`300`		`- batch->logits = (int8_t ) malloc(sizeof(int8_t) n_tokens);`
	`300`	`+ batch->output = (int8_t ) malloc(sizeof(int8_t) n_tokens);`
`301`	`301`
`302`	`302`	`return reinterpret_cast<jlong>(batch);`
`303`	`303`	`}`
`@@ -381,7 +381,7 @@ Java_android_llama_cpp_LLamaAndroid_completion_1init(`
`381`	`381`	`}`
`382`	`382`
`383`	`383`	`// llama_decode will output logits only for the last token of the prompt`
`384`		`- batch->logits[batch->n_tokens - 1] = true;`
	`384`	`+ batch->output[batch->n_tokens - 1] = true;`
`385`	`385`
`386`	`386`	`if (llama_decode(context, *batch) != 0) {`
`387`	`387`	`LOGe("llama_decode() failed");`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,14 @@ func llama_batch_clear(_ batch: inout llama_batch) {`
`9`	`9`	`batch.n_tokens = 0`
`10`	`10`	`}`
`11`	`11`
`12`		`-func llama_batch_add(_ batch: inout llama_batch, _ id: llama_token, _ pos: llama_pos, _ seq_ids: [llama_seq_id], _ logits: Bool) {`
	`12`	`+func llama_batch_add(_ batch: inout llama_batch, _ id: llama_token, _ pos: llama_pos, _ seq_ids: [llama_seq_id], _ outputs: Bool) {`
`13`	`13`	`batch.token [Int(batch.n_tokens)] = id`
`14`	`14`	`batch.pos [Int(batch.n_tokens)] = pos`
`15`	`15`	`batch.n_seq_id[Int(batch.n_tokens)] = Int32(seq_ids.count)`
`16`	`16`	`for i in 0..<seq_ids.count {`
`17`	`17`	`batch.seq_id[Int(batch.n_tokens)]![Int(i)] = seq_ids[i]`
`18`	`18`	`}`
`19`		`- batch.logits [Int(batch.n_tokens)] = logits ? 1 : 0`
	`19`	`+ batch.outputs [Int(batch.n_tokens)] = outputs ? 1 : 0`
`20`	`20`
`21`	`21`	`batch.n_tokens += 1`
`22`	`22`	`}`
`@@ -139,7 +139,7 @@ actor LlamaContext {`
`139`	`139`	`let i = Int(i1)`
`140`	`140`	`llama_batch_add(&batch, tokens_list[i], Int32(i), [0], false)`
`141`	`141`	`}`
`142`		`- batch.logits[Int(batch.n_tokens) - 1] = 1 // true`
	`142`	`+ batch.output[Int(batch.n_tokens) - 1] = 1 // true`
`143`	`143`
`144`	`144`	`if llama_decode(context, batch) != 0 {`
`145`	`145`	`print("llama_decode() failed")`
`@@ -208,7 +208,7 @@ actor LlamaContext {`
`208`	`208`	`for i in 0..<n_tokens {`
`209`	`209`	`llama_batch_add(&batch, 0, Int32(i), [0], false)`
`210`	`210`	`}`
`211`		`- batch.logits[Int(batch.n_tokens) - 1] = 1 // true`
	`211`	`+ batch.output[Int(batch.n_tokens) - 1] = 1 // true`
`212`	`212`
`213`	`213`	`llama_kv_cache_clear(context)`
`214`	`214`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ int main(int argc, char ** argv) {`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`if (i + n_batch >= n_tokens_all) {`
`149`		`- batch.logits[batch.n_tokens - 1] = true;`
	`149`	`+ batch.output[batch.n_tokens - 1] = true;`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`if (llama_decode(ctx, batch) != 0) {`
`@@ -180,7 +180,7 @@ int main(int argc, char ** argv) {`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`if (i + n_batch >= n_tokens_all) {`
`183`		`- batch.logits[batch.n_tokens - 1] = true;`
	`183`	`+ batch.output[batch.n_tokens - 1] = true;`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`if (llama_decode(ctx, batch) != 0) {`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ static void batch_decode(llama_context * ctx, llama_batch & batch, float * outpu`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`for (int i = 0; i < batch.n_tokens; i++) {`
`95`		`- if (!batch.logits[i]) {`
	`95`	`+ if (!batch.output[i]) {`
`96`	`96`	`continue;`
`97`	`97`	`}`
`98`	`98`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ int main(int argc, char ** argv) {`
`52`	`52`	`for (size_t i = 0; i < tokens.size(); i++) {`
`53`	`53`	`common_batch_add(batch, tokens[i], i, {0}, false);`
`54`	`54`	`}`
`55`		`- batch.logits[batch.n_tokens - 1] = true; // generate next token`
	`55`	`+ batch.output[batch.n_tokens - 1] = true; // generate next token`
`56`	`56`
`57`	`57`	`// evaluate prompt`
`58`	`58`	`llama_decode(ctx, batch);`
Original file line number	Diff line number	Diff line change
`@@ -102,17 +102,17 @@ void llama_sbatch::add_seq_to_ubatch(llama_ubatch & ubatch, llama_sbatch_seq & s`
`102`	`102`	`ubatch.output[ubatch.n_tokens + i] = 1;`
`103`	`103`	`out_ids.push_back(ids[seq.offset + i]);`
`104`	`104`	`}`
`105`		`- } else if (batch->logits) {`
	`105`	`+ } else if (batch->output) {`
`106`	`106`	`if (ubatch.equal_seqs) {`
`107`	`107`	`for (size_t i = 0; i < length; ++i) {`
`108`	`108`	`size_t id = ids[seq.offset + i];`
`109`		`- int8_t is_output = batch->logits[id];`
	`109`	`+ int8_t is_output = batch->output[id];`
`110`	`110`	`ubatch.output[ubatch.n_tokens + i] = is_output;`
`111`	`111`	`if (is_output) { out_ids.push_back(id); }`
`112`	`112`	`}`
`113`	`113`	`} else {`
`114`	`114`	`// simple split`
`115`		`- ubatch.output = batch->logits + seq.offset;`
	`115`	`+ ubatch.output = batch->output + seq.offset;`
`116`	`116`	`for (size_t i = 0; i < length; ++i) {`
`117`	`117`	`if (ubatch.output[i] != 0) { out_ids.push_back(seq.offset + i); }`
`118`	`118`	`}`
`@@ -298,10 +298,10 @@ llama_batch_allocr::llama_batch_allocr(struct llama_batch in_batch, llama_pos p0`
`298`	`298`	`}`
`299`	`299`	`batch.seq_id = seq_id.data();`
`300`	`300`	`}`
`301`		`- if (!batch.logits) {`
`302`		`- logits.resize(batch.n_tokens);`
`303`		`- logits[logits.size() - 1] = true;`
`304`		`- batch.logits = logits.data();`
	`301`	`+ if (!batch.output) {`
	`302`	`+ outputs.resize(batch.n_tokens);`
	`303`	`+ outputs[outputs.size() - 1] = true;`
	`304`	`+ batch.output = outputs.data();`
`305`	`305`	`}`
`306`	`306`	`}`
`307`	`307`
`@@ -348,7 +348,7 @@ struct llama_batch llama_batch_init(int32_t n_tokens_alloc, int32_t embd, int32_`
`348`	`348`	`}`
`349`	`349`	`batch.seq_id[n_tokens_alloc] = nullptr;`
`350`	`350`
`351`		`- batch.logits = (int8_t ) malloc(sizeof(int8_t) n_tokens_alloc);`
	`351`	`+ batch.output = (int8_t ) malloc(sizeof(int8_t) n_tokens_alloc);`
`352`	`352`
`353`	`353`	`return batch;`
`354`	`354`	`}`
`@@ -364,5 +364,5 @@ void llama_batch_free(struct llama_batch batch) {`
`364`	`364`	`}`
`365`	`365`	`free(batch.seq_id);`
`366`	`366`	`}`
`367`		`- if (batch.logits) free(batch.logits);`
	`367`	`+ if (batch.output) free(batch.output);`
`368`	`368`	`}`