Nicholas Beerbower
ed8dab4da4
Same fix pattern as test_stops: mkdtemp with a CWD-relative template (MinGW resolves Windows paths; /tmp is not one), and the fork/pipe/ truncate-based truncation subtest compiles only where those exist — Windows still runs the cross-platform chunk-loop content check. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
90 lines
3.3 KiB
C
90 lines
3.3 KiB
C
/* st_pread_full: chunk loop + honest truncation errors.
|
|
* Built with -DST_PREAD_CHUNK=7 so a ~100-byte tensor takes many pread calls —
|
|
* exercising the loop that production only needs past 2^31 bytes (one pread
|
|
* caps there on Linux; big bf16 tensors exceed it). Also forks a child against
|
|
* a truncated shard and requires exit(1) with a "short read" message instead
|
|
* of the old perror("... : Success"). */
|
|
#define _GNU_SOURCE
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#ifndef _WIN32
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "../st.h"
|
|
|
|
#define CHECK(condition) do { \
|
|
if (!(condition)) { \
|
|
fprintf(stderr, "%s:%d: check failed: %s\n", __FILE__, __LINE__, #condition); \
|
|
return 1; \
|
|
} \
|
|
} while (0)
|
|
|
|
static void write_snap(const char *dir, int truncate_bytes) {
|
|
char path[512];
|
|
snprintf(path, sizeof(path), "%s/model.safetensors", dir);
|
|
unsigned char data[96];
|
|
for (int i = 0; i < 96; i++) data[i] = (unsigned char)(i * 7 + 3);
|
|
const char *hdr = "{\"t\":{\"dtype\":\"U8\",\"shape\":[96],\"data_offsets\":[0,96]}}";
|
|
uint64_t hlen = strlen(hdr);
|
|
FILE *f = fopen(path, "wb");
|
|
fwrite(&hlen, 8, 1, f);
|
|
fwrite(hdr, 1, hlen, f);
|
|
fwrite(data, 1, (size_t)(96 - truncate_bytes), f);
|
|
fclose(f);
|
|
}
|
|
|
|
int main(void) {
|
|
/* relative to the CWD, per test_stops: MinGW .exe files resolve Windows
|
|
* paths and "/tmp" is not one */
|
|
char dir[] = "test_st_pread_XXXXXX";
|
|
if (!mkdtemp(dir)) { perror("mkdtemp"); return 1; }
|
|
|
|
/* 1) chunk loop: 96-byte tensor read 7 bytes at a time, content exact */
|
|
write_snap(dir, 0);
|
|
shards S; st_init(&S, dir);
|
|
unsigned char out[96] = {0};
|
|
st_read_raw(&S, "t", out, 0);
|
|
for (int i = 0; i < 96; i++) CHECK(out[i] == (unsigned char)(i * 7 + 3));
|
|
|
|
#ifndef _WIN32
|
|
/* 2) shard truncated AFTER st_init (init validates static bounds, so the
|
|
* pread path only fires when the file shrinks underneath a live handle):
|
|
* child must exit(1) with an honest message, not perror's "Success" */
|
|
char shard[512]; snprintf(shard, sizeof(shard), "%s/model.safetensors", dir);
|
|
struct stat sb; CHECK(stat(shard, &sb) == 0);
|
|
CHECK(truncate(shard, sb.st_size - 40) == 0);
|
|
int pipefd[2]; CHECK(pipe(pipefd) == 0);
|
|
pid_t pid = fork(); CHECK(pid >= 0);
|
|
if (pid == 0) {
|
|
dup2(pipefd[1], 2); close(pipefd[0]); close(pipefd[1]);
|
|
unsigned char buf[96];
|
|
st_read_raw(&S, "t", buf, 0); /* inherited handles; must exit(1) inside */
|
|
_exit(42); /* reaching here = bug */
|
|
}
|
|
close(pipefd[1]);
|
|
char err[512] = {0};
|
|
ssize_t n = read(pipefd[0], err, sizeof(err)-1); (void)n;
|
|
close(pipefd[0]);
|
|
int status = 0; waitpid(pid, &status, 0);
|
|
CHECK(WIFEXITED(status) && WEXITSTATUS(status) == 1);
|
|
CHECK(strstr(err, "short read") != NULL);
|
|
CHECK(strstr(err, "Success") == NULL);
|
|
#else
|
|
/* fork/pipe/truncate are POSIX; Windows still runs the chunk-loop check */
|
|
printf("test_st_pread: truncation subtest skipped on Windows\n");
|
|
#endif
|
|
|
|
char cmd[600];
|
|
#ifdef _WIN32
|
|
snprintf(cmd, sizeof(cmd), "rmdir /s /q %s", dir);
|
|
#else
|
|
snprintf(cmd, sizeof(cmd), "rm -rf %s", dir);
|
|
#endif
|
|
if (system(cmd)) {}
|
|
printf("test_st_pread: chunk loop + honest truncation error: ok\n");
|
|
return 0;
|
|
}
|